
#include "ap/IPCPSignalManager.h"
#include <transfer/utils.h>

namespace ecarx::transfer{


    void IPCPSignalManager::setAccFusnTrfcReq(AccFusnTrfcReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AccFusnTrfcReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAsyEmgyManoeuvreAidActvSts(AsyEmgyManoeuvreAidActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AsyEmgyManoeuvreAidActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutoLaneChgStyleSwSts(sdb::HmiAutoLaneChgStyle value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutoLaneChgStyleSwSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutoLaneChgWithNaviSwOnoff(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutoLaneChgWithNaviSwOnoff);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBSDSwOnOff(BSDSwOnOff& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BSDSwOnOff);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBSDSwOnOffandWarnType(sdb::WarmType value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BSDSwOnOffandWarnType);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBSDaudioOnOff(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BSDaudioOnOff);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBkpOfDstTrvld(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BkpOfDstTrvld);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCllsnAidSnvtySeldSts(CllsnAidSnvtySeldSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CllsnAidSnvtySeldSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCllsnMtgtnActvSeldSts(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CllsnMtgtnActvSeldSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCnclFaceReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CnclFaceReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCnclFaceReqForProf(CnclFaceReqForProf& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CnclFaceReqForProf);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCnclFaceReqGid1(CnclFaceReqGid1& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CnclFaceReqGid1);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCnclFaceReqGid2(CnclFaceReqGid2& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CnclFaceReqGid2);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCtraSwOnOff(CtraSwOnOff& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CtraSwOnOff);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDOWSwOnOff(DOWSwOnOff& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DOWSwOnOff);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvModReq(sdb::DrvModReqType2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvModReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrAsscSysBtnPush(sdb::DrvrAsscSysBtnPush value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrAsscSysBtnPush);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrAsscSysParkMod(sdb::DrvrFbOfPrkgMod2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrAsscSysParkMod);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrLaneChgAutActvSts(DrvrLaneChgAutActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrLaneChgAutActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrPfmncMonActvSts(DrvrPfmncMonActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrPfmncMonActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDstToDestination(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DstToDestination);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEmgyLaneKeepAidActvSts(EmgyLaneKeepAidActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EmgyLaneKeepAidActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFaceGid1(FaceGid1& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FaceGid1);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFaceGid2(FaceGid2& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FaceGid2);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFaceIdnReq(FaceIdnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FaceIdnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFaceSgnInForProf(FaceSgnInForProf& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FaceSgnInForProf);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFaceSgnInReq(sdb::YesNo1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FaceSgnInReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setGidInfoInp1(GidInfoInp1& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::GidInfoInp1);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setGidInfoInp2(GidInfoInp2& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::GidInfoInp2);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznData(HznData& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznData);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznEdge(HznEdge& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznEdge);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznPosn(HznPosn& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznPosn);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznProfLong(HznProfLong& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznProfLong);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznProfSho(HznProfSho& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznProfSho);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznSeg(HznSeg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznSeg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHznSplyElectcSts(sdb::HznSplyElectcSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HznSplyElectcSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setIHUfail(sdb::IhuErrSts value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::IHUfail);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setIntvAndWarnModForLaneKeepAidSts(sdb::IntvAndWarnModForLaneKeepAidSts value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::IntvAndWarnModForLaneKeepAidSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLDACSoftBtnSwtSt(sdb::LDACSoftBtnSwtSt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LDACSoftBtnSwtSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLaneKeepAidActvSts(LaneKeepAidActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LaneKeepAidActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setNOPCofmOfLanChagOnoff(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::NOPCofmOfLanChagOnoff);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setNOPRemindTypOfChgLaneReq(sdb::HmiNOPRemindOfChgLane value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::NOPRemindTypOfChgLaneReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setOffsForSpdWarnSetgReqSts(sdb::SetgReqSts value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::OffsForSpdWarnSetgReqSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPdcMuteBtnReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PdcMuteBtnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPlannedPahDe(sdb::NoYesCrit1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PlannedPahDe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPrkgCmftModTiCtrl(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PrkgCmftModTiCtrl);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPrkgDstCtrlSysSwt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PrkgDstCtrlSysSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPrkgTypAutBtn(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PrkgTypAutBtn);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPtDrvrSetg(PtDrvrSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PtDrvrSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRCWSwOnOff(RCWSwOnOff& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RCWSwOnOff);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRestStopGuidanceForDrvrPfmncMon(RestStopGuidanceForDrvrPfmncMon& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RestStopGuidanceForDrvrPfmncMon);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRoadMiscSgnInfoForRoadSgnInfoSts(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RoadMiscSgnInfoForRoadSgnInfoSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRoadSgnInfoActvSts(RoadSgnInfoActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RoadSgnInfoActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSpdAlrmActvForRoadSgnInfoSts(sdb::DY1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SpdAlrmActvForRoadSgnInfoSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSpdCamFromNavMap(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SpdCamFromNavMap);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSteerSetg(SteerSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SteerSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrfcLiActvSts(TrfcLiActvSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrfcLiActvSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrfcLiWarnTyp(TrfcLiWarnTyp& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrfcLiWarnTyp);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setVstdModeSts(sdb::Mode5 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::VstdModeSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWarnTypForLaneKeepAidSts(WarnTypForLaneKeepAidSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WarnTypForLaneKeepAidSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::AsyIndcrDispSts IPCPSignalManager::getAsyALatIndcr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALatIndcr));
        }
        if (signal.has_value()){
            return sdb::AsyIndcrDispSts(signal->value.int32Values[0]);
        }
        return sdb::AsyIndcrDispSts(-1);
    }

    sdb::AsyIndcrDispSts IPCPSignalManager::getAsyALgtIndcr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALgtIndcr));
        }
        if (signal.has_value()){
            return sdb::AsyIndcrDispSts(signal->value.int32Values[0]);
        }
        return sdb::AsyIndcrDispSts(-1);
    }

    sdb::AsyAutDrvgAvl IPCPSignalManager::getAsyAutDrvgAvl() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyAutDrvgAvl));
        }
        if (signal.has_value()){
            return sdb::AsyAutDrvgAvl(signal->value.int32Values[0]);
        }
        return sdb::AsyAutDrvgAvl(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAsyEmgyLaneKeepAid() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyEmgyLaneKeepAid));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::AsyALatSts IPCPSignalManager::getAsyEmgyLaneKeepAidSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyEmgyLaneKeepAidSts));
        }
        if (signal.has_value()){
            return sdb::AsyALatSts(signal->value.int32Values[0]);
        }
        return sdb::AsyALatSts(-1);
    }

    sdb::AsyEmgyLaneSts IPCPSignalManager::getAsyEmgyLaneSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyEmgyLaneSts));
        }
        if (signal.has_value()){
            return sdb::AsyEmgyLaneSts(signal->value.int32Values[0]);
        }
        return sdb::AsyEmgyLaneSts(-1);
    }

    sdb::FctaOn1 IPCPSignalManager::getAsyEmgyManoeuvreAidSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyEmgyManoeuvreAidSts));
        }
        if (signal.has_value()){
            return sdb::FctaOn1(signal->value.int32Values[0]);
        }
        return sdb::FctaOn1(-1);
    }

    sdb::ChgWarnMod IPCPSignalManager::getAsyLaneChgWarnMod() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyLaneChgWarnMod));
        }
        if (signal.has_value()){
            return sdb::ChgWarnMod(signal->value.int32Values[0]);
        }
        return sdb::ChgWarnMod(-1);
    }

    sdb::AsyALatSts IPCPSignalManager::getAsyLaneKeepAidSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyLaneKeepAidSts));
        }
        if (signal.has_value()){
            return sdb::AsyALatSts(signal->value.int32Values[0]);
        }
        return sdb::AsyALatSts(-1);
    }

    sdb::AsyLineLeColor IPCPSignalManager::getAsyLineLeColor() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyLineLeColor));
        }
        if (signal.has_value()){
            return sdb::AsyLineLeColor(signal->value.int32Values[0]);
        }
        return sdb::AsyLineLeColor(-1);
    }

    sdb::AsyLineLeColor IPCPSignalManager::getAsyLineRiColor() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyLineRiColor));
        }
        if (signal.has_value()){
            return sdb::AsyLineLeColor(signal->value.int32Values[0]);
        }
        return sdb::AsyLineLeColor(-1);
    }

    sdb::LvlWarn1 IPCPSignalManager::getAsySteerApplyRqrd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsySteerApplyRqrd));
        }
        if (signal.has_value()){
            return sdb::LvlWarn1(signal->value.int32Values[0]);
        }
        return sdb::LvlWarn1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getCllsnAidPost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnAidPost));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::CllsnFwdWarnReq IPCPSignalManager::getCllsnFwdWarn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnFwdWarn));
        }
        if (signal.has_value()){
            return sdb::CllsnFwdWarnReq(signal->value.int32Values[0]);
        }
        return sdb::CllsnFwdWarnReq(-1);
    }

    sdb::CllsnMtgtnFctSts IPCPSignalManager::getCllsnMtgtnFctSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnMtgtnFctSts));
        }
        if (signal.has_value()){
            return sdb::CllsnMtgtnFctSts(signal->value.int32Values[0]);
        }
        return sdb::CllsnMtgtnFctSts(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getCllsnMtgtnOnoffSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnMtgtnOnoffSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::CllsnMtgtnWarnSts IPCPSignalManager::getCllsnMtgtnWarnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnMtgtnWarnSts));
        }
        if (signal.has_value()){
            return sdb::CllsnMtgtnWarnSts(signal->value.int32Values[0]);
        }
        return sdb::CllsnMtgtnWarnSts(-1);
    }

    sdb::LcmaCtraOn IPCPSignalManager::getCllsnWarnReOn1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CllsnWarnReOn1));
        }
        if (signal.has_value()){
            return sdb::LcmaCtraOn(signal->value.int32Values[0]);
        }
        return sdb::LcmaCtraOn(-1);
    }

    sdb::FailSuccess IPCPSignalManager::getCnclFaceRes() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CnclFaceRes));
        }
        if (signal.has_value()){
            return sdb::FailSuccess(signal->value.int32Values[0]);
        }
        return sdb::FailSuccess(-1);
    }

    sdb::LvlWarn2 IPCPSignalManager::getCnclWarnForAutDrv() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CnclWarnForAutDrv));
        }
        if (signal.has_value()){
            return sdb::LvlWarn2(signal->value.int32Values[0]);
        }
        return sdb::LvlWarn2(-1);
    }

    sdb::LcmaCtraOn IPCPSignalManager::getCtraOn1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CtraOn1));
        }
        if (signal.has_value()){
            return sdb::LcmaCtraOn(signal->value.int32Values[0]);
        }
        return sdb::LcmaCtraOn(-1);
    }

    sdb::LcmaCtraOn IPCPSignalManager::getDoorOpenwarnOn1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DoorOpenwarnOn1));
        }
        if (signal.has_value()){
            return sdb::LcmaCtraOn(signal->value.int32Values[0]);
        }
        return sdb::LcmaCtraOn(-1);
    }

    int32_t IPCPSignalManager::getDrvrAsscSysDisp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrAsscSysDisp));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DrvrAsscSysSts IPCPSignalManager::getDrvrAsscSysSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrAsscSysSts));
        }
        if (signal.has_value()){
            return sdb::DrvrAsscSysSts(signal->value.int32Values[0]);
        }
        return sdb::DrvrAsscSysSts(-1);
    }

    sdb::DrvrPfmncSwtichSts IPCPSignalManager::getDrvrPfmncSwitchSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrPfmncSwitchSts));
        }
        if (signal.has_value()){
            return sdb::DrvrPfmncSwtichSts(signal->value.int32Values[0]);
        }
        return sdb::DrvrPfmncSwtichSts(-1);
    }

    sdb::FaceIdnStsMsg IPCPSignalManager::getFaceIdnStsMsg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceIdnStsMsg));
        }
        if (signal.has_value()){
            return sdb::FaceIdnStsMsg(signal->value.int32Values[0]);
        }
        return sdb::FaceIdnStsMsg(-1);
    }

    sdb::FailSuccess IPCPSignalManager::getFaceInfoAcqRes() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceInfoAcqRes));
        }
        if (signal.has_value()){
            return sdb::FailSuccess(signal->value.int32Values[0]);
        }
        return sdb::FailSuccess(-1);
    }

    float IPCPSignalManager::getFaceInfoAcqSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceInfoAcqSts));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getFrntLeOfSnsrOfPrkgAssiSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntLeOfSnsrOfPrkgAssiSide));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getFrntRiOfSnsrOfPrkgAssiSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntRiOfSnsrOfPrkgAssiSide));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getInsdLeOfSnsrPrkgAssiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::InsdLeOfSnsrPrkgAssiFrnt));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getInsdLeOfSnsrPrkgAssiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::InsdLeOfSnsrPrkgAssiRe));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getInsdRiOfSnsrPrkgAssiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::InsdRiOfSnsrPrkgAssiFrnt));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getInsdRiOfSnsrPrkgAssiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::InsdRiOfSnsrPrkgAssiRe));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::IntvAndWarnModForLaneKeepAidSts IPCPSignalManager::getIntvAndWarnModInfoSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntvAndWarnModInfoSts));
        }
        if (signal.has_value()){
            return sdb::IntvAndWarnModForLaneKeepAidSts(signal->value.int32Values[0]);
        }
        return sdb::IntvAndWarnModForLaneKeepAidSts(-1);
    }

    sdb::LaneChgAutStsForAsyHiWay IPCPSignalManager::getLaneChgAutStsForAsyHiWay() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LaneChgAutStsForAsyHiWay));
        }
        if (signal.has_value()){
            return sdb::LaneChgAutStsForAsyHiWay(signal->value.int32Values[0]);
        }
        return sdb::LaneChgAutStsForAsyHiWay(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getLaneChgWarnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LaneChgWarnSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getLaneKeepAidInfoSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LaneKeepAidInfoSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getLcmaAudWarn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LcmaAudWarn));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::LcmaCtraOn IPCPSignalManager::getLcmaOn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LcmaOn));
        }
        if (signal.has_value()){
            return sdb::LcmaCtraOn(signal->value.int32Values[0]);
        }
        return sdb::LcmaCtraOn(-1);
    }

    sdb::DrvrPfmncSwtichSts IPCPSignalManager::getNavForDrvrPfmncSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::NavForDrvrPfmncSts));
        }
        if (signal.has_value()){
            return sdb::DrvrPfmncSwtichSts(signal->value.int32Values[0]);
        }
        return sdb::DrvrPfmncSwtichSts(-1);
    }

    sdb::ObjOnIfOfSnsr IPCPSignalManager::getObjOnIfOfSnsr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ObjOnIfOfSnsr));
        }
        if (signal.has_value()){
            return sdb::ObjOnIfOfSnsr(signal->value.int32Values[0]);
        }
        return sdb::ObjOnIfOfSnsr(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getOutdLeOfSnsrPrkgAssiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdLeOfSnsrPrkgAssiFrnt));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getOutdLeOfSnsrPrkgAssiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdLeOfSnsrPrkgAssiRe));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getOutdRiOfSnsrPrkgAssiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdRiOfSnsrPrkgAssiFrnt));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getOutdRiOfSnsrPrkgAssiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdRiOfSnsrPrkgAssiRe));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getPdcMuteBtnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PdcMuteBtnSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::PrkgDstCtrlSysSts IPCPSignalManager::getPrkgDstCtrlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrkgDstCtrlSts));
        }
        if (signal.has_value()){
            return sdb::PrkgDstCtrlSysSts(signal->value.int32Values[0]);
        }
        return sdb::PrkgDstCtrlSysSts(-1);
    }

    sdb::PEBSysSts IPCPSignalManager::getPrkgEmgyBrkSysSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrkgEmgyBrkSysSts));
        }
        if (signal.has_value()){
            return sdb::PEBSysSts(signal->value.int32Values[0]);
        }
        return sdb::PEBSysSts(-1);
    }

    int32_t IPCPSignalManager::getPrkgProgsDisp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrkgProgsDisp));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::OnOff1 IPCPSignalManager::getPrkgTypAutBtnCfmd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrkgTypAutBtnCfmd));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::LcmaIndcn IPCPSignalManager::getRctaIndcnLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RctaIndcnLe));
        }
        if (signal.has_value()){
            return sdb::LcmaIndcn(signal->value.int32Values[0]);
        }
        return sdb::LcmaIndcn(-1);
    }

    sdb::LcmaIndcn IPCPSignalManager::getRctaIndcnRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RctaIndcnRi));
        }
        if (signal.has_value()){
            return sdb::LcmaIndcn(signal->value.int32Values[0]);
        }
        return sdb::LcmaIndcn(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getReLeOfSnsrOfPrkgAssiSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReLeOfSnsrOfPrkgAssiSide));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::SnsrPrkgAssiFrntSnsrDstInsd IPCPSignalManager::getReRiOfSnsrOfPrkgAssiSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReRiOfSnsrOfPrkgAssiSide));
        }
        if (signal.has_value()){
            return sdb::SnsrPrkgAssiFrntSnsrDstInsd(signal->value.int32Values[0]);
        }
        return sdb::SnsrPrkgAssiFrntSnsrDstInsd(-1);
    }

    sdb::TrfcSgnInfoSts IPCPSignalManager::getRoadSgnInfoSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RoadSgnInfoSts));
        }
        if (signal.has_value()){
            return sdb::TrfcSgnInfoSts(signal->value.int32Values[0]);
        }
        return sdb::TrfcSgnInfoSts(-1);
    }

    sdb::SnsrDrvrPfmncSts IPCPSignalManager::getSnsrDrvrPfmncSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SnsrDrvrPfmncSts));
        }
        if (signal.has_value()){
            return sdb::SnsrDrvrPfmncSts(signal->value.int32Values[0]);
        }
        return sdb::SnsrDrvrPfmncSts(-1);
    }

    sdb::SnsrFltOfPrkgDstCtrl IPCPSignalManager::getSnsrFltOfPrkgDstCtrl() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SnsrFltOfPrkgDstCtrl));
        }
        if (signal.has_value()){
            return sdb::SnsrFltOfPrkgDstCtrl(signal->value.int32Values[0]);
        }
        return sdb::SnsrFltOfPrkgDstCtrl(-1);
    }

    sdb::SoftBtnSwtStCfmd IPCPSignalManager::getSoftBtnSwtStCfmd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SoftBtnSwtStCfmd));
        }
        if (signal.has_value()){
            return sdb::SoftBtnSwtStCfmd(signal->value.int32Values[0]);
        }
        return sdb::SoftBtnSwtStCfmd(-1);
    }

    sdb::FctSts2 IPCPSignalManager::getTrfcLiSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrfcLiSts));
        }
        if (signal.has_value()){
            return sdb::FctSts2(signal->value.int32Values[0]);
        }
        return sdb::FctSts2(-1);
    }

    sdb::VisAlrmReq IPCPSignalManager::getVisAlrmReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VisAlrmReq));
        }
        if (signal.has_value()){
            return sdb::VisAlrmReq(signal->value.int32Values[0]);
        }
        return sdb::VisAlrmReq(-1);
    }

    sdb::AsyALgtSts IPCPSignalManager::getAsyALgtStsAsyALgtSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALgtStsAsyALgtSts));
        }
        if (signal.has_value()){
            return sdb::AsyALgtSts(signal->value.int32Values[0]);
        }
        return sdb::AsyALgtSts(-1);
    }

    int32_t IPCPSignalManager::getAsyALgtStsChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALgtStsChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAsyALgtStsCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALgtStsCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::EyeGazeZone1 IPCPSignalManager::getEyeGazeZone() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EyeGazeZone));
        }
        if (signal.has_value()){
            return sdb::EyeGazeZone1(signal->value.int32Values[0]);
        }
        return sdb::EyeGazeZone1(-1);
    }

    int32_t IPCPSignalManager::getEyeGazeZoneTime() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EyeGazeZoneTime));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::IdPen IPCPSignalManager::getFaceIdnResForProfIdPen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceIdnResForProfIdPen));
        }
        if (signal.has_value()){
            return sdb::IdPen(signal->value.int32Values[0]);
        }
        return sdb::IdPen(-1);
    }

    sdb::YesNo2 IPCPSignalManager::getFaceIdnResForProfYesNo() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceIdnResForProfYesNo));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte0));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte3));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte5));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo1Byte7() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo1Byte7));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte0));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte3));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte5));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFaceRecgGidInfo2Byte7() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FaceRecgGidInfo2Byte7));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::AsyHandsOffIndcr IPCPSignalManager::getAsyHandsOffIndcrAsyHandsOffIndcr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyHandsOffIndcrAsyHandsOffIndcr));
        }
        if (signal.has_value()){
            return sdb::AsyHandsOffIndcr(signal->value.int32Values[0]);
        }
        return sdb::AsyHandsOffIndcr(-1);
    }

    sdb::NoYes1 IPCPSignalManager::getAsyFctnIhbtByTrlr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyFctnIhbtByTrlr));
        }
        if (signal.has_value()){
            return sdb::NoYes1(signal->value.int32Values[0]);
        }
        return sdb::NoYes1(-1);
    }

    sdb::DrvrPfmncWarnReq IPCPSignalManager::getDrvrPfmncAlrmReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrPfmncAlrmReq));
        }
        if (signal.has_value()){
            return sdb::DrvrPfmncWarnReq(signal->value.int32Values[0]);
        }
        return sdb::DrvrPfmncWarnReq(-1);
    }

    void IPCPSignalManager::setANCcfgToAmplfr(sdb::ActvNoiseCtrl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ANCcfgToAmplfr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAcoustMod(sdb::NoYesCrit1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AcoustMod);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setArtificialSoundOpenReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ArtificialSoundOpenReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setArtificialSoundPreviewReq(ArtificialSoundPreviewReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ArtificialSoundPreviewReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setArtificialSoundSelectReq(sdb::SteerMod value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ArtificialSoundSelectReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiHvacFanLvlFrnt(sdb::HmiHvacFanLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiHvacFanLvlFrnt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setVehSpdLvl(sdb::VehSpdLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::VehSpdLvl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    int32_t IPCPSignalManager::getAmplifrErrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmplifrErrSts));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::OnOff1 IPCPSignalManager::getArtificialSoundOpenReqSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ArtificialSoundOpenReqSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::ActvnAvl2 IPCPSignalManager::getArtificialSoundPreviewSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ArtificialSoundPreviewSts));
        }
        if (signal.has_value()){
            return sdb::ActvnAvl2(signal->value.int32Values[0]);
        }
        return sdb::ActvnAvl2(-1);
    }

    sdb::SteerMod IPCPSignalManager::getArtificialSoundSelectReqSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ArtificialSoundSelectReqSts));
        }
        if (signal.has_value()){
            return sdb::SteerMod(signal->value.int32Values[0]);
        }
        return sdb::SteerMod(-1);
    }

    sdb::OffOnErrInvalid IPCPSignalManager::getSwtOfICCSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtOfICCSts));
        }
        if (signal.has_value()){
            return sdb::OffOnErrInvalid(signal->value.int32Values[0]);
        }
        return sdb::OffOnErrInvalid(-1);
    }

    int32_t IPCPSignalManager::getVehSpdLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLvlSts));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::NoYesCrit1 IPCPSignalManager::getAcoustModSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AcoustModSts));
        }
        if (signal.has_value()){
            return sdb::NoYesCrit1(signal->value.int32Values[0]);
        }
        return sdb::NoYesCrit1(-1);
    }

    void IPCPSignalManager::setCmftBrkStpSwt(sdb::CmftBrkStpSwt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CmftBrkStpSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEpbApplyAutSetg(EpbApplyAutSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EpbApplyAutSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEpbSoftSwtCtrlSt(sdb::EpbSoftSwtCtrlSt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EpbSoftSwtCtrlSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::Disply IPCPSignalManager::getBrkModSoftSwtStsAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkModSoftSwtStsAvlSts));
        }
        if (signal.has_value()){
            return sdb::Disply(signal->value.int32Values[0]);
        }
        return sdb::Disply(-1);
    }

    sdb::Brkmod IPCPSignalManager::getBrkModSoftSwtStsEnaSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkModSoftSwtStsEnaSts));
        }
        if (signal.has_value()){
            return sdb::Brkmod(signal->value.int32Values[0]);
        }
        return sdb::Brkmod(-1);
    }

    sdb::VehMtnSt2 IPCPSignalManager::getVehMtnStVehMtnSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMtnStVehMtnSt));
        }
        if (signal.has_value()){
            return sdb::VehMtnSt2(signal->value.int32Values[0]);
        }
        return sdb::VehMtnSt2(-1);
    }

    sdb::YesNo2 IPCPSignalManager::getEpbApplyEnaSec() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EpbApplyEnaSec));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    sdb::YesNo2 IPCPSignalManager::getEpbRelsEnaSec() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EpbRelsEnaSec));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    void IPCPSignalManager::setActvnOfSwtIllmnCen(sdb::Boolean value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ActvnOfSwtIllmnCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::PsdNotPsd IPCPSignalManager::getDriModBut() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DriModBut));
        }
        if (signal.has_value()){
            return sdb::PsdNotPsd(signal->value.int32Values[0]);
        }
        return sdb::PsdNotPsd(-1);
    }

    sdb::PsdNotPsd IPCPSignalManager::getCsdPowBut() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CsdPowBut));
        }
        if (signal.has_value()){
            return sdb::PsdNotPsd(signal->value.int32Values[0]);
        }
        return sdb::PsdNotPsd(-1);
    }

    sdb::PsdNotPsd IPCPSignalManager::getCusKeyBut() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CusKeyBut));
        }
        if (signal.has_value()){
            return sdb::PsdNotPsd(signal->value.int32Values[0]);
        }
        return sdb::PsdNotPsd(-1);
    }

    void IPCPSignalManager::setARFootKickTrSettng(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ARFootKickTrSettng);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiMod(AmbLiMod& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiMod);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiModExt(sdb::AmbLiMod01 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiModExt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutClsLockHMIReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutClsLockHMIReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutClsWinSet(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutClsWinSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAuxHiBeamSetReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AuxHiBeamSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackRestAdjmtRowFirstDrvr(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackRestAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackRestAdjmtRowFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackRestAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackrestAdjmtRowSecLe(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackrestAdjmtRowSecLe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackrestAdjmtRowSecRi(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackrestAdjmtRowSecRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCushExtnFirstDrvr(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CushExtnFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCushExtnFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CushExtnFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDhuCpuLoadSts(float value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DhuCpuLoadSts);
        signal.value.floatValues={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDhuLoadAmbliSet(sdb::DhuLoadAmbliSet value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DhuLoadAmbliSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrSeatDispMassgFct(DrvrSeatDispMassgFct& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrSeatDispMassgFct);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDrvrSeatDispSpplFct(sdb::SeatActvSpplFct1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DrvrSeatDispSpplFct);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEasyInOutDrvrSeatAdjmt(EasyInOutDrvrSeatAdjmt& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EasyInOutDrvrSeatAdjmt);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEasyInOutFrntPassReq(sdb::EasyInOut value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EasyInOutFrntPassReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEasyInOutTriModSet(EasyInOutTriModSet& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EasyInOutTriModSet);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEasyOutDriSeatPosSet(EasyOutDriSeatPosSet& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EasyOutDriSeatPosSet);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEasyOutPassSeatPosSet(EasyOutPassSeatPosSet& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EasyOutPassSeatPosSet);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setExtrMirrFoldHmiReq(sdb::PsdNotPsd1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ExtrMirrFoldHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setExtrMirrFoldSetg(sdb::ExtrMirrFoldSet value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ExtrMirrFoldSetg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestExtonAdjmtRowFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestExtonAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestExtonAdjmtRowSecLe(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestExtonAdjmtRowSecLe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestExtonAdjmtRowSecRi(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestExtonAdjmtRowSecRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestRotAdjmtRowFirstPass(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestRotAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestRotAdjmtRowSecLe(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestRotAdjmtRowSecLe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLegRestRotAdjmtRowSecRi(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LegRestRotAdjmtRowSecRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLenAdjmtRowSecLe(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LenAdjmtRowSecLe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLenAdjmtRowSecRi(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LenAdjmtRowSecRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLumHeiAdjmtRowFirstDrvr(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LumHeiAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLumHeiAdjmtRowFirstPass(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LumHeiAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLumLenAdjmtRowFirstDrvr(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LumLenAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLumLenAdjmtRowFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LumLenAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setMemSoftBtnPsd(MemSoftBtnPsd& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::MemSoftBtnPsd);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPasAcsHmi(PasAcsHmi& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PasAcsHmi);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPassSceneModSeld(sdb::PatSeld value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PassSceneModSeld);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPassSeatDispMassgFct(PassSeatDispMassgFct& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PassSeatDispMassgFct);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPassSeatDispSpplFct(sdb::SeatActvSpplFct1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PassSeatDispSpplFct);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPetModExitWarn(sdb::LvlWarn2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PetModExitWarn);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setProfChg(sdb::IdPen value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ProfChg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSceneModSeld(sdb::PatSeld value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SceneModSeld);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatCushTiltAdjmtRowFirstDrvr(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatCushTiltAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatCushTiltAdjmtRowFirstPass(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatCushTiltAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatDispBtnPsd(SeatDispBtnPsd& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatDispBtnPsd);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatLenAdjmtRowFirstDrvr(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatLenAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatLenAdjmtRowFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatLenAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSunCurtOpenPosnReq(sdb::WinAndRoofAndCurtPosnTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SunCurtOpenPosnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setUnlckRemReq(UnlckRemReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::UnlckRemReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWalkAwayLockReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WalkAwayLockReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWiprFrntSrvModReq(sdb::WiprSrvModReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WiprFrntSrvModReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWiprReAutReq(WiprReAutReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WiprReAutReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWiprReSrvModReq(sdb::WiprSrvModReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WiprReSrvModReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::ARFootKickTrSettngSts IPCPSignalManager::getARFootKickTrSetgSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ARFootKickTrSetgSts));
        }
        if (signal.has_value()){
            return sdb::ARFootKickTrSettngSts(signal->value.int32Values[0]);
        }
        return sdb::ARFootKickTrSettngSts(-1);
    }

    sdb::Boolean IPCPSignalManager::getApprchInbhStsToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ApprchInbhStsToHmi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::DispInfo IPCPSignalManager::getAutMoveDispToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutMoveDispToHmi));
        }
        if (signal.has_value()){
            return sdb::DispInfo(signal->value.int32Values[0]);
        }
        return sdb::DispInfo(-1);
    }

    float IPCPSignalManager::getCarTiGlb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarTiGlb));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtBlstrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtBlstrSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::MirrFoldStsTyp IPCPSignalManager::getMirrFoldStsAtDrvr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MirrFoldStsAtDrvr));
        }
        if (signal.has_value()){
            return sdb::MirrFoldStsTyp(signal->value.int32Values[0]);
        }
        return sdb::MirrFoldStsTyp(-1);
    }

    sdb::MirrFoldStsTyp IPCPSignalManager::getMirrFoldStsAtPass() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MirrFoldStsAtPass));
        }
        if (signal.has_value()){
            return sdb::MirrFoldStsTyp(signal->value.int32Values[0]);
        }
        return sdb::MirrFoldStsTyp(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtBlstrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtBlstrSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::EnableDisableCoding IPCPSignalManager::getWinClsAutEnaSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinClsAutEnaSts));
        }
        if (signal.has_value()){
            return sdb::EnableDisableCoding(signal->value.int32Values[0]);
        }
        return sdb::EnableDisableCoding(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getWiprInPosnForSrv() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WiprInPosnForSrv));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getWiprReInPosnForSrv() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WiprReInPosnForSrv));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    float IPCPSignalManager::getPassSeatLegRstHeiPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatLegRstHeiPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getPassSeatLegRstHeiPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatLegRstHeiPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getPassSeatLegRstLenPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatLegRstLenPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getPassSeatLegRstLenPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatLegRstLenPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    int32_t IPCPSignalManager::getSwtExtrLi3LiExtFctCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi3LiExtFctCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSwtExtrLi3LiExtFctCrc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi3LiExtFctCrc));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getSwtExtrLi3LiExtFctQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi3LiExtFctQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::LiExtFctReq1 IPCPSignalManager::getSwtExtrLi3LiExtFctReq1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi3LiExtFctReq1));
        }
        if (signal.has_value()){
            return sdb::LiExtFctReq1(signal->value.int32Values[0]);
        }
        return sdb::LiExtFctReq1(-1);
    }

    sdb::NoYes1 IPCPSignalManager::getVehTiAndDataDataValid() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataDataValid));
        }
        if (signal.has_value()){
            return sdb::NoYes1(signal->value.int32Values[0]);
        }
        return sdb::NoYes1(-1);
    }

    int32_t IPCPSignalManager::getVehTiAndDataDay() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataDay));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehTiAndDataHr1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataHr1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehTiAndDataMins1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataMins1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehTiAndDataMth1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataMth1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehTiAndDataSec1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataSec1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehTiAndDataYr1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehTiAndDataYr1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::SeatActvSpplFct1 IPCPSignalManager::getDrvrSeatActvSpplFct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatActvSpplFct));
        }
        if (signal.has_value()){
            return sdb::SeatActvSpplFct1(signal->value.int32Values[0]);
        }
        return sdb::SeatActvSpplFct1(-1);
    }

    sdb::Boolean IPCPSignalManager::getDrvrSeatExtAdjAllowd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatExtAdjAllowd));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::SeatActvSpplFct1 IPCPSignalManager::getPassSeatActvSpplFct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatActvSpplFct));
        }
        if (signal.has_value()){
            return sdb::SeatActvSpplFct1(signal->value.int32Values[0]);
        }
        return sdb::SeatActvSpplFct1(-1);
    }

    int32_t IPCPSignalManager::getSeatBackAngleRowFirstDrvr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatBackAngleRowFirstDrvr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSeatBackAngleRowFirstPass() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatBackAngleRowFirstPass));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Boolean IPCPSignalManager::getSunCurtMvngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SunCurtMvngSts));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::WinAndRoofAndCurtPosnTyp IPCPSignalManager::getSunCurtPosnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SunCurtPosnSts));
        }
        if (signal.has_value()){
            return sdb::WinAndRoofAndCurtPosnTyp(signal->value.int32Values[0]);
        }
        return sdb::WinAndRoofAndCurtPosnTyp(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtAdjmtOfSpplFctHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtAdjmtOfSpplFctHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtAdjmtOfSpplFctVertSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtAdjmtOfSpplFctVertSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtHdrstHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtHdrstHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtHdrstVertSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtHdrstVertSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtHeiFrntSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtHeiFrntSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtHeiSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtHeiSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtInclSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtInclSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtSelnOfSpplFctSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtSelnOfSpplFctSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtStsDrvrSeatSwtSldSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtStsDrvrSeatSwtSldSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtHdrstVertSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtHdrstVertSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtHeiFrntSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtHeiFrntSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtHeiSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtHeiSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtAdjmtOfSpplFctHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtAdjmtOfSpplFctHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtAdjmtOfSpplFctVerSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtAdjmtOfSpplFctVerSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtHdrstHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtHdrstHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtInclSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtInclSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtSelnOfSpplFctStsSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtSelnOfSpplFctStsSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtSts2PassSeatSwtSldSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtSts2PassSeatSwtSldSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getDrvrMassgRunng() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrMassgRunng));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getPassMassgRunng() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassMassgRunng));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::Boolean IPCPSignalManager::getDrvrSeatBtnPsd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatBtnPsd));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    float IPCPSignalManager::getDrvrSeatPosPercSeatPosSldPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosSldPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Boolean IPCPSignalManager::getPassSeatBtnPsd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatBtnPsd));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    float IPCPSignalManager::getPassSeatPosPercSeatPosSldPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosSldPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getPassSeatPosPercSeatPosSldQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosSldQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getPassSeatPosPercSeatPosFrntHeiPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosFrntHeiPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getPassSeatPosPercSeatPosFrntHeiQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosFrntHeiQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getPassSeatPosPercSeatPosHeiPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosHeiPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getPassSeatPosPercSeatPosHeiQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatPosPercSeatPosHeiQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getDrvrSeatPosPercSeatPosFrntHeiPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosFrntHeiPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getDrvrSeatPosPercSeatPosFrntHeiQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosFrntHeiQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getDrvrSeatPosPercSeatPosHeiPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosHeiPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getDrvrSeatPosPercSeatPosHeiQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosHeiQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::Qf1 IPCPSignalManager::getDrvrSeatPosPercSeatPosSldQF() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatPosPercSeatPosSldQF));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getChrgnUReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnUReq));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::YesNo2 IPCPSignalManager::getDiagcExtCom() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DiagcExtCom));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    sdb::FoldSetSts IPCPSignalManager::getExtrMirrFoldSetSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrMirrFoldSetSts));
        }
        if (signal.has_value()){
            return sdb::FoldSetSts(signal->value.int32Values[0]);
        }
        return sdb::FoldSetSts(-1);
    }

    sdb::IdPen IPCPSignalManager::getProfPenSts1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ProfPenSts1));
        }
        if (signal.has_value()){
            return sdb::IdPen(signal->value.int32Values[0]);
        }
        return sdb::IdPen(-1);
    }

    sdb::Boolean IPCPSignalManager::getRowSecLeBtnPsd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeBtnPsd));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    int32_t IPCPSignalManager::getRowSecLeInclPosAngle() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeInclPosAngle));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Boolean IPCPSignalManager::getRowSecRiBtnPsd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiBtnPsd));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    int32_t IPCPSignalManager::getRowSecRiInclPosAngle() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiInclPosAngle));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::MemPosn IPCPSignalManager::getLoadAndStoreReqErgoPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LoadAndStoreReqErgoPosn));
        }
        if (signal.has_value()){
            return sdb::MemPosn(signal->value.int32Values[0]);
        }
        return sdb::MemPosn(-1);
    }

    sdb::EveMemPosn IPCPSignalManager::getLoadAndStoreReqErgoSetgEve() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LoadAndStoreReqErgoSetgEve));
        }
        if (signal.has_value()){
            return sdb::EveMemPosn(signal->value.int32Values[0]);
        }
        return sdb::EveMemPosn(-1);
    }

    sdb::IdPen IPCPSignalManager::getLoadAndStoreReqIdPen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LoadAndStoreReqIdPen));
        }
        if (signal.has_value()){
            return sdb::IdPen(signal->value.int32Values[0]);
        }
        return sdb::IdPen(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getLoadAndStoreReqInOutEasy() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LoadAndStoreReqInOutEasy));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    float IPCPSignalManager::getRowSecLeLegRstHeiPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeLegRstHeiPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecLeLegRstHeiPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeLegRstHeiPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getRowSecLeLegRstLenPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeLegRstLenPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecLeLegRstLenPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeLegRstLenPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getRowSecLeSldPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeSldPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecLeSldPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeSldPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getRowSecRiLegRstHeiPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiLegRstHeiPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecRiLegRstHeiPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiLegRstHeiPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getRowSecRiLegRstLenPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiLegRstLenPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecRiLegRstLenPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiLegRstLenPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getRowSecRiSldPosPercSeatPosPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiSldPosPercSeatPosPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getRowSecRiSldPosPercSeatPosQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiSldPosPercSeatPosQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtAdjmtOfSpplFctHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtAdjmtOfSpplFctHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtAdjmtOfSpplFctVerSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtAdjmtOfSpplFctVerSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtHdrstHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtHdrstHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtHdrstVertSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtHdrstVertSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtHeiFrntSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtHeiFrntSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtHeiSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtHeiSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtInclSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtInclSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtSelnOfSpplFctStsSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtSelnOfSpplFctStsSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecLeSwtStsPassSeatSwtSldSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecLeSwtStsPassSeatSwtSldSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtAdjmtOfSpplFctHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtAdjmtOfSpplFctHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtAdjmtOfSpplFctVerSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtAdjmtOfSpplFctVerSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtHdrstHozlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtHdrstHozlSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtHdrstVertSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtHdrstVertSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtHeiFrntSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtHeiFrntSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtHeiSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtHeiSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtInclSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtInclSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtVertSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtSelnOfSpplFctStsSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtSelnOfSpplFctStsSts));
        }
        if (signal.has_value()){
            return sdb::SwtVertSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtVertSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getSeatRowSecRiSwtStsPassSeatSwtSldSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatRowSecRiSwtStsPassSeatSwtSldSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    void IPCPSignalManager::setAFSSetReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AFSSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setActvAllSeatCeremonyModReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ActvAllSeatCeremonyModReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAllRoofLiSwtFromHmi(sdb::Boolean value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AllRoofLiSwtFromHmi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiAll(AmbLiAll& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiAll);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiChrgCorrlnReq(AmbLiChrgCorrlnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiChrgCorrlnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiClimateCorrlnReq(AmbLiClimateCorrlnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiClimateCorrlnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiDrvModCorrlnReq(AmbLiDrvModCorrlnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiDrvModCorrlnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiEnduranceMilgOpenReq(AmbLiEnduranceMilgOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiEnduranceMilgOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiMusicCorrlnReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiMusicCorrlnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiMusicShowTyp(AmbLiMusicShowTyp& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiMusicShowTyp);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiPhoneOpenReq(AmbLiPhoneOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiPhoneOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiSpeechCorrlnReq(AmbLiSpeechCorrlnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiSpeechCorrlnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiSwapEffectStatus(AmbLiSwapEffectStatus& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiSwapEffectStatus);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiThemeModSelnReq(AmbLiThemeModSelnReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiThemeModSelnReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAmbLiWelcomeShowTyp(AmbLiWelcomeShowTyp& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AmbLiWelcomeShowTyp);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAntithftRednReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AntithftRednReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setApproachLiSetReq(sdb::ApproachLiSetReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ApproachLiSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutClsSunShdSet(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutClsSunShdSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutHiBeamSwt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutHiBeamSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackRestSideSpprtAdjmtRowFirstDrvr(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackRestSideSpprtAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBackRestSideSpprtAdjmtRowFirstPass(sdb::SwtHozlSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BackRestSideSpprtAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBendingLiSetReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BendingLiSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setBevPwrCtrl(sdb::Boolean value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::BevPwrCtrl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCarFindrHornLiSetActv(sdb::CarFindrHornLiSetActv value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CarFindrHornLiSetActv);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCbnOverHeatProtnEna(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CbnOverHeatProtnEna);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCenLockHmiReq(sdb::LockgCenReq2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CenLockHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChdLockReLeCtrlHmiReq(sdb::LockgCenReq2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChdLockReLeCtrlHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChdLockReRiCtrlHmiReq(sdb::LockgCenReq2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChdLockReRiCtrlHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChrgLidCtrlHmiReq(ChrgLidCtrlHmiReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChrgLidCtrlHmiReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChrgnLiSwt(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChrgnLiSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setClsAutEna(sdb::EnableDisableCoding value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ClsAutEna);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCourtesyLiOpenReq(CourtesyLiOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CourtesyLiOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCushSideSpprtAdjmtRowFirstDrvr(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CushSideSpprtAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCushSideSpprtAdjmtRowFirstPass(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::CushSideSpprtAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDoubleLockOpenHmiReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DoubleLockOpenHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setExtrMirrTiltSetg(ExtrMirrTiltSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ExtrMirrTiltSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFogSetRearReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FogSetRearReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setFragRefrshAutSetg(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::FragRefrshAutSetg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setGoodbyeLiOpenReq(GoodbyeLiOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::GoodbyeLiOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setGrilleLampColorSelnReq(sdb::SteerMod value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::GrilleLampColorSelnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHMIClimaEgySaveReq(sdb::VentnActr01BlckInd value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HMIClimaEgySaveReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiCmptmtTSp(HmiCmptmtTSp& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiCmptmtTSp);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiFragraChRatReq(HmiFragraChRatReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiFragraChRatReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiFragraLvlReq(sdb::HmiFragraLvlReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiFragraLvlReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiFragraModReq(sdb::HmiFrangraModReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiFragraModReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiHumCtrlEna(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiHumCtrlEna);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiPassTempSyncSet(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiPassTempSyncSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiPopUpResp(sdb::BookChargeSetResponse value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiPopUpResp);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiSeatClima(HmiSeatClima& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiSeatClima);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiSeatClimaTmr(HmiSeatClimaTmr& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiSeatClimaTmr);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHoodUnlckHmiReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HoodUnlckHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHzrdWarnSigSwt(sdb::PsdNotPsd value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HzrdWarnSigSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setInteCleanUnpleSmell(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::InteCleanUnpleSmell);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setIntrBriLvlCtrlSts(IntrBriLvlCtrlSts& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::IntrBriLvlCtrlSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLiCornrgReq(LiCornrgReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LiCornrgReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLiHomeSafeReq(LiHomeSafeReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LiHomeSafeReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLockgFbSoundReq(LockgFbSoundReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LockgFbSoundReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLvlgSwtSetReq(LvlgSwtSetReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LvlgSwtSetReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setParkGearUnlckHmiReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ParkGearUnlckHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPasAlrmDeactvnReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PasAlrmDeactvnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRainSnsrSnvtyHMIReq(sdb::WipgSpdIntlFromHmi value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RainSnsrSnvtyHMIReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setReadLiOpenReq(ReadLiOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ReadLiOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setRescModSwt(sdb::YesNo2 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::RescModSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSayHiBtnReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SayHiBtnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatHeiAdjmtRowFirstDrvr(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatHeiAdjmtRowFirstDrvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSeatHeiAdjmtRowFirstPass(sdb::SwtVertSts1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SeatHeiAdjmtRowFirstPass);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSecRowLeSeatDispMassgFct(SecRowLeSeatDispMassgFct& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SecRowLeSeatDispMassgFct);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSecRowRiSeatDispMassgFct(SecRowRiSeatDispMassgFct& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SecRowRiSeatDispMassgFct);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSetTiAndDate(SetTiAndDate& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SetTiAndDate);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSngDoorOrFourDoorSelectReq(SngDoorOrFourDoorSelectReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SngDoorOrFourDoorSelectReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSoftLiBtnSwtSetReq(SoftLiBtnSwtSetReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SoftLiBtnSwtSetReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setStarModBtnReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::StarModBtnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSteerWhlHeatgOnReq(sdb::SteerWhlHeatgOnCmdTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SteerWhlHeatgOnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSteerWhlHeatngAutStrtReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SteerWhlHeatngAutStrtReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTWinRfClsdPopUpReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TWinRfClsdPopUpReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTaillampboundReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TaillampboundReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTiAndDateGNSS(TiAndDateGNSS& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TiAndDateGNSS);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTopPercTrFromHmi(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TopPercTrFromHmi);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTopPosTrFromHmi(sdb::PosPerc1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TopPosTrFromHmi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrOpenPosnReqFromHmi(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrOpenPosnReqFromHmi);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrfcSideSetReq(sdb::RiLeTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrfcSideSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrlrLampChkAutReq(TrlrLampChkAutReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrlrLampChkAutReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrlrLampChkReqFromHmi(sdb::StrtStopReq1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrlrLampChkReqFromHmi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTrunkOpenHmiReq(sdb::DoorOpenerReq1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TrunkOpenHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWaitForLtgReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WaitForLtgReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWaitModBtnReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WaitModBtnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWelcomeGoodbyeModeReq(sdb::ModeReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WelcomeGoodbyeModeReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWelcomeGoodbyeSetReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WelcomeGoodbyeSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWelcomeLiOpenReq(WelcomeLiOpenReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WelcomeLiOpenReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinDiReLeSwt(sdb::PsdNotPsd value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinDiReLeSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinDiReRiSwt(sdb::PsdNotPsd value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinDiReRiSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinOpenDrvrReq(sdb::WinAndRoofAndCurtPosnTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinOpenDrvrReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinOpenPassReq(sdb::WinAndRoofAndCurtPosnTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinOpenPassReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinOpenReLeReq(sdb::WinAndRoofAndCurtPosnTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinOpenReLeReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWinOpenReRiReq(sdb::WinAndRoofAndCurtPosnTyp value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WinOpenReRiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setZone1Settings(Zone1Settings& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::Zone1Settings);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setZone2Settings(Zone2Settings& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::Zone2Settings);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::Boolean IPCPSignalManager::getACChrgLidInhbStsToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ACChrgLidInhbStsToHmi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAirFragCh1RunngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh1RunngSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAirFragCh2RunngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh2RunngSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAirFragCh3RunngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh3RunngSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAirFragCh4RunngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh4RunngSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAirFragCh5RunngSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh5RunngSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::CarFindrHornLiSetActv IPCPSignalManager::getCarLoctrHornLiSetActv() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarLoctrHornLiSetActv));
        }
        if (signal.has_value()){
            return sdb::CarFindrHornLiSetActv(signal->value.int32Values[0]);
        }
        return sdb::CarFindrHornLiSetActv(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getChrgLidAcSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgLidAcSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getChrgLidDCorAcDcSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgLidDCorAcDcSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getChrgnLtgSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnLtgSts));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::Boolean IPCPSignalManager::getDCChrgLidInhbStsToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCChrgLidInhbStsToHmi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getDoorDrvrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DoorDrvrSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getDoorLeReSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DoorLeReSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getDoorPassSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DoorPassSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    sdb::DoorSts2 IPCPSignalManager::getDoorRiReSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DoorRiReSts));
        }
        if (signal.has_value()){
            return sdb::DoorSts2(signal->value.int32Values[0]);
        }
        return sdb::DoorSts2(-1);
    }

    int32_t IPCPSignalManager::getFragCh1Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh1Id));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Warn2 IPCPSignalManager::getFragCh1UseUpWrn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh1UseUpWrn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    int32_t IPCPSignalManager::getFragCh2Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh2Id));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Warn2 IPCPSignalManager::getFragCh2UseUpWrn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh2UseUpWrn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    int32_t IPCPSignalManager::getFragCh3Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh3Id));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Warn2 IPCPSignalManager::getFragCh3UseUpWrn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh3UseUpWrn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    int32_t IPCPSignalManager::getFragCh4Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh4Id));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Warn2 IPCPSignalManager::getFragCh4UseUpWrn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh4UseUpWrn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    int32_t IPCPSignalManager::getFragCh5Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh5Id));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Warn2 IPCPSignalManager::getFragCh5UseUpWrn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragCh5UseUpWrn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    sdb::RatUse IPCPSignalManager::getFragLvlFrmClima() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragLvlFrmClima));
        }
        if (signal.has_value()){
            return sdb::RatUse(signal->value.int32Values[0]);
        }
        return sdb::RatUse(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getFragRefreshPopUp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragRefreshPopUp));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::AirFrgSts IPCPSignalManager::getFragStsFrmClima() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FragStsFrmClima));
        }
        if (signal.has_value()){
            return sdb::AirFrgSts(signal->value.int32Values[0]);
        }
        return sdb::AirFrgSts(-1);
    }

    sdb::HoodSts IPCPSignalManager::getHoodSts1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HoodSts1));
        }
        if (signal.has_value()){
            return sdb::HoodSts(signal->value.int32Values[0]);
        }
        return sdb::HoodSts(-1);
    }

    int32_t IPCPSignalManager::getIntrBriSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntrBriSts));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::LockSt2 IPCPSignalManager::getLockgCenStsForUsrFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LockgCenStsForUsrFb));
        }
        if (signal.has_value()){
            return sdb::LockSt2(signal->value.int32Values[0]);
        }
        return sdb::LockSt2(-1);
    }

    sdb::NoReqOffReq IPCPSignalManager::getPasAlrmSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PasAlrmSts));
        }
        if (signal.has_value()){
            return sdb::NoReqOffReq(signal->value.int32Values[0]);
        }
        return sdb::NoReqOffReq(-1);
    }

    sdb::OkNotOk IPCPSignalManager::getSteerWhlHeatgStrtAutCdnOk() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlHeatgStrtAutCdnOk));
        }
        if (signal.has_value()){
            return sdb::OkNotOk(signal->value.int32Values[0]);
        }
        return sdb::OkNotOk(-1);
    }

    int32_t IPCPSignalManager::getTopPosHmiFeedBack2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TopPosHmiFeedBack2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::TwliBriSts1 IPCPSignalManager::getTwliBriSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TwliBriSts));
        }
        if (signal.has_value()){
            return sdb::TwliBriSts1(signal->value.int32Values[0]);
        }
        return sdb::TwliBriSts1(-1);
    }

    sdb::WinAndRoofAndCurtPosnTyp IPCPSignalManager::getWinPosnStsAtDrvr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinPosnStsAtDrvr));
        }
        if (signal.has_value()){
            return sdb::WinAndRoofAndCurtPosnTyp(signal->value.int32Values[0]);
        }
        return sdb::WinAndRoofAndCurtPosnTyp(-1);
    }

    sdb::WinAndRoofAndCurtPosnTyp IPCPSignalManager::getWinPosnStsAtPass() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinPosnStsAtPass));
        }
        if (signal.has_value()){
            return sdb::WinAndRoofAndCurtPosnTyp(signal->value.int32Values[0]);
        }
        return sdb::WinAndRoofAndCurtPosnTyp(-1);
    }

    sdb::WinAndRoofAndCurtPosnTyp IPCPSignalManager::getWinPosnStsAtReLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinPosnStsAtReLe));
        }
        if (signal.has_value()){
            return sdb::WinAndRoofAndCurtPosnTyp(signal->value.int32Values[0]);
        }
        return sdb::WinAndRoofAndCurtPosnTyp(-1);
    }

    sdb::WinAndRoofAndCurtPosnTyp IPCPSignalManager::getWinPosnStsAtReRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinPosnStsAtReRi));
        }
        if (signal.has_value()){
            return sdb::WinAndRoofAndCurtPosnTyp(signal->value.int32Values[0]);
        }
        return sdb::WinAndRoofAndCurtPosnTyp(-1);
    }

    int32_t IPCPSignalManager::getActvnOfIndcrIndcrOutChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ActvnOfIndcrIndcrOutChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getActvnOfIndcrIndcrOutCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ActvnOfIndcrIndcrOutCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAmbIllmnFwdStsAmblillmn1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbIllmnFwdStsAmblillmn1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAmbIllmnFwdStsAmblillmn2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbIllmnFwdStsAmblillmn2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAmbIllmnFwdStsChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbIllmnFwdStsChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAmbIllmnFwdStsCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbIllmnFwdStsCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getAmbTRawAmbTVal() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbTRawAmbTVal));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getAmbTRawQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AmbTRawQly));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    sdb::FrntWiprLvrCmd1 IPCPSignalManager::getFrntWiprLvrCmd2FrntWiprLvrCmd1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntWiprLvrCmd2FrntWiprLvrCmd1));
        }
        if (signal.has_value()){
            return sdb::FrntWiprLvrCmd1(signal->value.int32Values[0]);
        }
        return sdb::FrntWiprLvrCmd1(-1);
    }

    int32_t IPCPSignalManager::getFrntWiprLvrCmd2FrntWiprLvrCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntWiprLvrCmd2FrntWiprLvrCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getFrntWiprLvrCmd2FrntWiprLvrCrc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntWiprLvrCmd2FrntWiprLvrCrc));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getFrntWiprLvrCmd2FrntWiprLvrQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntWiprLvrCmd2FrntWiprLvrQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgBattLoSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgBattLoSt));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgFastLoseWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgFastLoseWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgMsgOldFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgMsgOldFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    float IPCPSignalManager::getLeFrntTireMsgP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgP));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::PWarnFlg IPCPSignalManager::getLeFrntTireMsgPWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgPWarnFlg));
        }
        if (signal.has_value()){
            return sdb::PWarnFlg(signal->value.int32Values[0]);
        }
        return sdb::PWarnFlg(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgSysWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgSysWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    int32_t IPCPSignalManager::getLeFrntTireMsgT() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgT));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgTWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgTWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeFrntTireMsgTireFillgAssiPSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgTireFillgAssiPSts));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgBattLoSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgBattLoSt));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgFastLoseWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgFastLoseWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgMsgOldFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgMsgOldFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    float IPCPSignalManager::getLeReTireMsgP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgP));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::PWarnFlg IPCPSignalManager::getLeReTireMsgPWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgPWarnFlg));
        }
        if (signal.has_value()){
            return sdb::PWarnFlg(signal->value.int32Values[0]);
        }
        return sdb::PWarnFlg(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgSysWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgSysWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    int32_t IPCPSignalManager::getLeReTireMsgT() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgT));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgTWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgTWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getLeReTireMsgTireFillgAssiPSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgTireFillgAssiPSts));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::LockSt3 IPCPSignalManager::getLockgCenStsLockSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LockgCenStsLockSt));
        }
        if (signal.has_value()){
            return sdb::LockSt3(signal->value.int32Values[0]);
        }
        return sdb::LockSt3(-1);
    }

    sdb::LockTrigSrc2 IPCPSignalManager::getLockgCenStsTrigSrc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LockgCenStsTrigSrc));
        }
        if (signal.has_value()){
            return sdb::LockTrigSrc2(signal->value.int32Values[0]);
        }
        return sdb::LockTrigSrc2(-1);
    }

    sdb::Boolean IPCPSignalManager::getLockgCenStsUpdEve() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LockgCenStsUpdEve));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgBattLoSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgBattLoSt));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgFastLoseWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgFastLoseWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgMsgOldFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgMsgOldFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    float IPCPSignalManager::getRiFrntTireMsgP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgP));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::PWarnFlg IPCPSignalManager::getRiFrntTireMsgPWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgPWarnFlg));
        }
        if (signal.has_value()){
            return sdb::PWarnFlg(signal->value.int32Values[0]);
        }
        return sdb::PWarnFlg(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgSysWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgSysWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    int32_t IPCPSignalManager::getRiFrntTireMsgT() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgT));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgTWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgTWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiFrntTireMsgTireFillgAssiPSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgTireFillgAssiPSts));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgBattLoSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgBattLoSt));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgFastLoseWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgFastLoseWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgMsgOldFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgMsgOldFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    float IPCPSignalManager::getRiReTireMsgP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgP));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::PWarnFlg IPCPSignalManager::getRiReTireMsgPWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgPWarnFlg));
        }
        if (signal.has_value()){
            return sdb::PWarnFlg(signal->value.int32Values[0]);
        }
        return sdb::PWarnFlg(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgSysWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgSysWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    int32_t IPCPSignalManager::getRiReTireMsgT() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgT));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgTWarnFlg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgTWarnFlg));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::Normalwarning IPCPSignalManager::getRiReTireMsgTireFillgAssiPSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgTireFillgAssiPSts));
        }
        if (signal.has_value()){
            return sdb::Normalwarning(signal->value.int32Values[0]);
        }
        return sdb::Normalwarning(-1);
    }

    sdb::NoYes1 IPCPSignalManager::getTiAndDateIndcnDataValid() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnDataValid));
        }
        if (signal.has_value()){
            return sdb::NoYes1(signal->value.int32Values[0]);
        }
        return sdb::NoYes1(-1);
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnDay() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnDay));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnHr1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnHr1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnMins1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnMins1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnMth1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnMth1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnSec1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnSec1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getTiAndDateIndcnYr1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TiAndDateIndcnYr1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsReFog() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsReFog));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::LiExtFctReq1 IPCPSignalManager::getSwtExtrLi2LiExtFctReq1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi2LiExtFctReq1));
        }
        if (signal.has_value()){
            return sdb::LiExtFctReq1(signal->value.int32Values[0]);
        }
        return sdb::LiExtFctReq1(-1);
    }

    sdb::ReqSts1 IPCPSignalManager::getAutoDeHumPopUp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutoDeHumPopUp));
        }
        if (signal.has_value()){
            return sdb::ReqSts1(signal->value.int32Values[0]);
        }
        return sdb::ReqSts1(-1);
    }

    sdb::OnOffSafe1 IPCPSignalManager::getChdLockRightStsToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChdLockRightStsToHmi));
        }
        if (signal.has_value()){
            return sdb::OnOffSafe1(signal->value.int32Values[0]);
        }
        return sdb::OnOffSafe1(-1);
    }

    sdb::OnOffSafe1 IPCPSignalManager::getChdPrtnLeftStsToHmi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChdPrtnLeftStsToHmi));
        }
        if (signal.has_value()){
            return sdb::OnOffSafe1(signal->value.int32Values[0]);
        }
        return sdb::OnOffSafe1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getClimaOvrHeatProActvSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ClimaOvrHeatProActvSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getEcoClimaSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EcoClimaSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsFirstRowLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsFirstRowLe));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsFirstRowRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsFirstRowRi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsSecondRowLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsSecondRowLe));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsSecondRowRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsSecondRowRi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsThirdRowLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsThirdRowLe));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getReadLiStsThirdRowRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ReadLiStsThirdRowRi));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getSeatHeatgLvlStsRowSecLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatHeatgLvlStsRowSecLe));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getSeatHeatgLvlStsRowSecRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatHeatgLvlStsRowSecRi));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getSeatVentnLvlStsRowSecLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatVentnLvlStsRowSecLe));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getSeatVentnLvlStsRowSecRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatVentnLvlStsRowSecRi));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::OccptPresSt1 IPCPSignalManager::getRowFrstPassODSSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowFrstPassODSSts));
        }
        if (signal.has_value()){
            return sdb::OccptPresSt1(signal->value.int32Values[0]);
        }
        return sdb::OccptPresSt1(-1);
    }

    sdb::OccptPresSt1 IPCPSignalManager::getRowSecLeODSSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeODSSts));
        }
        if (signal.has_value()){
            return sdb::OccptPresSt1(signal->value.int32Values[0]);
        }
        return sdb::OccptPresSt1(-1);
    }

    sdb::OccptPresSt1 IPCPSignalManager::getRowSecRiODSSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiODSSts));
        }
        if (signal.has_value()){
            return sdb::OccptPresSt1(signal->value.int32Values[0]);
        }
        return sdb::OccptPresSt1(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getDrvrSeatVentnLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatVentnLvlSts));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getPassSeatVentnLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatVentnLvlSts));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::StsFd IPCPSignalManager::getDrvrSeatHeatgAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatHeatgAvlSts));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getPassSeatHeatgAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatHeatgAvlSts));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getSeatHeatgAvlStsRowSecLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatHeatgAvlStsRowSecLe));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getSeatHeatgAvlStsRowSecRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatHeatgAvlStsRowSecRi));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getDrvrSeatHeatgLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatHeatgLvlSts));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::SeatClimaLvl IPCPSignalManager::getPassSeatHeatgLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatHeatgLvlSts));
        }
        if (signal.has_value()){
            return sdb::SeatClimaLvl(signal->value.int32Values[0]);
        }
        return sdb::SeatClimaLvl(-1);
    }

    sdb::StsFd IPCPSignalManager::getDrvrSeatVentAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatVentAvlSts));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getPassSeatVentAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatVentAvlSts));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getSeatVentAvlStsRowSecLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatVentAvlStsRowSecLe));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::StsFd IPCPSignalManager::getSeatVentAvlStsRowSecRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SeatVentAvlStsRowSecRi));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getDrvrSeatSwtCushExtSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSwtCushExtSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::SwtHozlSts1 IPCPSignalManager::getPassSeatSwtCushExtSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSwtCushExtSts));
        }
        if (signal.has_value()){
            return sdb::SwtHozlSts1(signal->value.int32Values[0]);
        }
        return sdb::SwtHozlSts1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getWinDsblLeftSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinDsblLeftSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getWinDsblRightSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinDsblRightSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::StsFd IPCPSignalManager::getSteerWhlHeatgAvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlHeatgAvlSts));
        }
        if (signal.has_value()){
            return sdb::StsFd(signal->value.int32Values[0]);
        }
        return sdb::StsFd(-1);
    }

    sdb::SteerWhlHeatgOnCmdTyp IPCPSignalManager::getSteerWhlHeatgLvlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlHeatgLvlSts));
        }
        if (signal.has_value()){
            return sdb::SteerWhlHeatgOnCmdTyp(signal->value.int32Values[0]);
        }
        return sdb::SteerWhlHeatgOnCmdTyp(-1);
    }

    sdb::TailgatePos IPCPSignalManager::getTopPosHmiFeedBack() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TopPosHmiFeedBack));
        }
        if (signal.has_value()){
            return sdb::TailgatePos(signal->value.int32Values[0]);
        }
        return sdb::TailgatePos(-1);
    }

    sdb::Boolean IPCPSignalManager::getTrAntiPnch() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrAntiPnch));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getTrObstclDetn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrObstclDetn));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::TrOpenerSts1 IPCPSignalManager::getTrOpenerSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrOpenerSts));
        }
        if (signal.has_value()){
            return sdb::TrOpenerSts1(signal->value.int32Values[0]);
        }
        return sdb::TrOpenerSts1(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getWaitModSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WaitModSts));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::Warn2 IPCPSignalManager::getWinRfClsdReqForCoolgDwn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WinRfClsdReqForCoolgDwn));
        }
        if (signal.has_value()){
            return sdb::Warn2(signal->value.int32Values[0]);
        }
        return sdb::Warn2(-1);
    }

    sdb::AirQly IPCPSignalManager::getOutdAirQlyOutdAirQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdAirQlyOutdAirQly));
        }
        if (signal.has_value()){
            return sdb::AirQly(signal->value.int32Values[0]);
        }
        return sdb::AirQly(-1);
    }

    sdb::OutdAirQlyQf IPCPSignalManager::getOutdAirQlyQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OutdAirQlyQf));
        }
        if (signal.has_value()){
            return sdb::OutdAirQlyQf(signal->value.int32Values[0]);
        }
        return sdb::OutdAirQlyQf(-1);
    }

    sdb::CarModSts1 IPCPSignalManager::getVehModMngtGlbSafe1CarModSts1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1CarModSts1));
        }
        if (signal.has_value()){
            return sdb::CarModSts1(signal->value.int32Values[0]);
        }
        return sdb::CarModSts1(-1);
    }

    sdb::UsgModSts1 IPCPSignalManager::getVehModMngtGlbSafe1UsgModSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1UsgModSts));
        }
        if (signal.has_value()){
            return sdb::UsgModSts1(signal->value.int32Values[0]);
        }
        return sdb::UsgModSts1(-1);
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1CarModSubtypWdCarModSubtyp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1CarModSubtypWdCarModSubtyp));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1Chks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1Chks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1Cntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1Cntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsAFS() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsAFS));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1EgyLvlElecMai() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1EgyLvlElecMai));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsAHBC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsAHBC));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1EgyLvlElecSubtyp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1EgyLvlElecSubtyp));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsAHL() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsAHL));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::FltEgyCns1 IPCPSignalManager::getVehModMngtGlbSafe1FltEgyCnsWdSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1FltEgyCnsWdSts));
        }
        if (signal.has_value()){
            return sdb::FltEgyCns1(signal->value.int32Values[0]);
        }
        return sdb::FltEgyCns1(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsAllWL() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsAllWL));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1PwrLvlElecMai() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1PwrLvlElecMai));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsApproach() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsApproach));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    int32_t IPCPSignalManager::getVehModMngtGlbSafe1PwrLvlElecSubtyp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehModMngtGlbSafe1PwrLvlElecSubtyp));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getExtrLtgStsChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getExtrLtgStsCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsCornrgLi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsCornrgLi));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsDBL() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsDBL));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsDRL() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsDRL));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsFlash() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsFlash));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsFrntFog() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsFrntFog));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsGoodbye() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsGoodbye));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsHWL() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsHWL));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsHiBeam() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsHiBeam));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsHomeSafe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsHomeSafe));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsLoBeam() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsLoBeam));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsLtgShow() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsLtgShow));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsPosLiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsPosLiFrnt));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsPosLiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsPosLiRe));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsReverseLi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsReverseLi));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsStopLi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsStopLi));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsTurnIndrLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsTurnIndrLe));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsTurnIndrRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsTurnIndrRi));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getExtrLtgStsWelcome() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsWelcome));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    int32_t IPCPSignalManager::getSwtExtrLi2LiExtFctCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi2LiExtFctCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSwtExtrLi2LiExtFctCrc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi2LiExtFctCrc));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getSwtExtrLi2LiExtFctQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtExtrLi2LiExtFctQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::TrlrPrsntSts IPCPSignalManager::getTrlrPrsnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrlrPrsnt));
        }
        if (signal.has_value()){
            return sdb::TrlrPrsntSts(signal->value.int32Values[0]);
        }
        return sdb::TrlrPrsntSts(-1);
    }

    sdb::IndcrSts1 IPCPSignalManager::getTrlrLiTurnIndcrActvt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrlrLiTurnIndcrActvt));
        }
        if (signal.has_value()){
            return sdb::IndcrSts1(signal->value.int32Values[0]);
        }
        return sdb::IndcrSts1(-1);
    }

    sdb::TrlrLampChkSts2 IPCPSignalManager::getTrlrLampChkSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrlrLampChkSts));
        }
        if (signal.has_value()){
            return sdb::TrlrLampChkSts2(signal->value.int32Values[0]);
        }
        return sdb::TrlrLampChkSts2(-1);
    }

    sdb::IndcrSts1 IPCPSignalManager::getActvnOfIndcrIndcrOut() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ActvnOfIndcrIndcrOut));
        }
        if (signal.has_value()){
            return sdb::IndcrSts1(signal->value.int32Values[0]);
        }
        return sdb::IndcrSts1(-1);
    }

    int32_t IPCPSignalManager::getAirFragCh1AvlTi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh1AvlTi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAirFragCh2AvlTi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh2AvlTi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAirFragCh3AvlTi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh3AvlTi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAirFragCh4AvlTi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh4AvlTi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAirFragCh5AvlTi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AirFragCh5AvlTi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::ClimaOffReq IPCPSignalManager::getClimaOffReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ClimaOffReq));
        }
        if (signal.has_value()){
            return sdb::ClimaOffReq(signal->value.int32Values[0]);
        }
        return sdb::ClimaOffReq(-1);
    }

    sdb::OccptPresSt1 IPCPSignalManager::getDrvrSeatSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatSts));
        }
        if (signal.has_value()){
            return sdb::OccptPresSt1(signal->value.int32Values[0]);
        }
        return sdb::OccptPresSt1(-1);
    }

    sdb::HvacFanSts IPCPSignalManager::getFrntHvacBlowerSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntHvacBlowerSts));
        }
        if (signal.has_value()){
            return sdb::HvacFanSts(signal->value.int32Values[0]);
        }
        return sdb::HvacFanSts(-1);
    }

    sdb::IntPmHiPopUp IPCPSignalManager::getIntPm25HiPopUp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntPm25HiPopUp));
        }
        if (signal.has_value()){
            return sdb::IntPmHiPopUp(signal->value.int32Values[0]);
        }
        return sdb::IntPmHiPopUp(-1);
    }

    sdb::CmpmtAirPmLvl IPCPSignalManager::getIntPm25LvlFrmClima() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntPm25LvlFrmClima));
        }
        if (signal.has_value()){
            return sdb::CmpmtAirPmLvl(signal->value.int32Values[0]);
        }
        return sdb::CmpmtAirPmLvl(-1);
    }

    sdb::PmSnsrSts IPCPSignalManager::getIntPm25StsFrmClima() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntPm25StsFrmClima));
        }
        if (signal.has_value()){
            return sdb::PmSnsrSts(signal->value.int32Values[0]);
        }
        return sdb::PmSnsrSts(-1);
    }

    int32_t IPCPSignalManager::getIntPm25VluFrmClima() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntPm25VluFrmClima));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Boolean IPCPSignalManager::getMirrBtnPsdAtDrvr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MirrBtnPsdAtDrvr));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::EnableDisableCoding IPCPSignalManager::getSunCurtClsAutEnaSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SunCurtClsAutEnaSts));
        }
        if (signal.has_value()){
            return sdb::EnableDisableCoding(signal->value.int32Values[0]);
        }
        return sdb::EnableDisableCoding(-1);
    }

    int32_t IPCPSignalManager::getTrOpenPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrOpenPosn));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    void IPCPSignalManager::setIntrBriLvlCtrlSts100(IntrBriLvlCtrlSts100& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::IntrBriLvlCtrlSts100);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setActvPriFunReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ActvPriFunReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutPriFocLenReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutPriFocLenReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setAutTrapCorrReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutTrapCorrReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setManTrapCorrnSet(ManTrapCorrnSet& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ManTrapCorrnSet);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPriBriSet(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PriBriSet);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPriFocLenSet(sdb::PriFocLenSet value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PriFocLenSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPrjScrenPosSet(PrjScrenPosSet& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PrjScrenPosSet);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::DevSts4 IPCPSignalManager::getAutPriFocLenFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutPriFocLenFb));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::DevSts4 IPCPSignalManager::getAutTrapCorrFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutTrapCorrFb));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getPriFocLenFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PriFocLenFb));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    int32_t IPCPSignalManager::getPrjtLiInten() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrjtLiInten));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DevSts4 IPCPSignalManager::getPrjtSwtFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrjtSwtFb));
        }
        if (signal.has_value()){
            return sdb::DevSts4(signal->value.int32Values[0]);
        }
        return sdb::DevSts4(-1);
    }

    sdb::LeRiPosn IPCPSignalManager::getManTrapCorrnLeDwnPosnLeRiPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnLeDwnPosnLeRiPosn));
        }
        if (signal.has_value()){
            return sdb::LeRiPosn(signal->value.int32Values[0]);
        }
        return sdb::LeRiPosn(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getManTrapCorrnLeDwnPosnUpDwnPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnLeDwnPosnUpDwnPosn));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    sdb::LeRiPosn IPCPSignalManager::getManTrapCorrnLeUpPosnLeRiPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnLeUpPosnLeRiPosn));
        }
        if (signal.has_value()){
            return sdb::LeRiPosn(signal->value.int32Values[0]);
        }
        return sdb::LeRiPosn(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getManTrapCorrnLeUpPosnUpDwnPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnLeUpPosnUpDwnPosn));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    sdb::LeRiPosn IPCPSignalManager::getManTrapCorrnRiDwnPosnLeRiPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnRiDwnPosnLeRiPosn));
        }
        if (signal.has_value()){
            return sdb::LeRiPosn(signal->value.int32Values[0]);
        }
        return sdb::LeRiPosn(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getManTrapCorrnRiDwnPosnUpDwnPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnRiDwnPosnUpDwnPosn));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    sdb::LeRiPosn IPCPSignalManager::getManTrapCorrnRiUpPosnLeRiPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnRiUpPosnLeRiPosn));
        }
        if (signal.has_value()){
            return sdb::LeRiPosn(signal->value.int32Values[0]);
        }
        return sdb::LeRiPosn(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getManTrapCorrnRiUpPosnUpDwnPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ManTrapCorrnRiUpPosnUpDwnPosn));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    sdb::LeRiPosn IPCPSignalManager::getProScrenPosnLeRiPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ProScrenPosnLeRiPosn));
        }
        if (signal.has_value()){
            return sdb::LeRiPosn(signal->value.int32Values[0]);
        }
        return sdb::LeRiPosn(-1);
    }

    sdb::PriFocLen IPCPSignalManager::getProScrenPosnUpDwnPosn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ProScrenPosnUpDwnPosn));
        }
        if (signal.has_value()){
            return sdb::PriFocLen(signal->value.int32Values[0]);
        }
        return sdb::PriFocLen(-1);
    }

    int32_t IPCPSignalManager::getHandsOnDetectionChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHandsOnDetectionCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::ErrorStaus IPCPSignalManager::getHandsOnDetectionErrorStatus() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionErrorStatus));
        }
        if (signal.has_value()){
            return sdb::ErrorStaus(signal->value.int32Values[0]);
        }
        return sdb::ErrorStaus(-1);
    }

    sdb::HandsOnStatus IPCPSignalManager::getHandsOnDetectionHandsOnStatus() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionHandsOnStatus));
        }
        if (signal.has_value()){
            return sdb::HandsOnStatus(signal->value.int32Values[0]);
        }
        return sdb::HandsOnStatus(-1);
    }

    int32_t IPCPSignalManager::getHandsOnDetectionMultiZoneChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionMultiZoneChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHandsOnDetectionMultiZoneCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionMultiZoneCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::ErrorStaus IPCPSignalManager::getHandsOnDetectionMultiZoneErrorStatus() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionMultiZoneErrorStatus));
        }
        if (signal.has_value()){
            return sdb::ErrorStaus(signal->value.int32Values[0]);
        }
        return sdb::ErrorStaus(-1);
    }

    sdb::HandsOnSts2 IPCPSignalManager::getHandsOnDetectionMultiZoneHandsOnStatus() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HandsOnDetectionMultiZoneHandsOnStatus));
        }
        if (signal.has_value()){
            return sdb::HandsOnSts2(signal->value.int32Values[0]);
        }
        return sdb::HandsOnSts2(-1);
    }

    void IPCPSignalManager::setHudRstForSetgAndData(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HudRstForSetgAndData);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::OnOff1 IPCPSignalManager::getHudActvSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HudActvSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::HudStsForHmi IPCPSignalManager::getHudSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HudSts));
        }
        if (signal.has_value()){
            return sdb::HudStsForHmi(signal->value.int32Values[0]);
        }
        return sdb::HudStsForHmi(-1);
    }

    int32_t IPCPSignalManager::getHudPosnUpldToDIMPosY() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HudPosnUpldToDIMPosY));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHudPosnUpldToDIMRot() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HudPosnUpldToDIMRot));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHudPosnUpldToDIMllmn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HudPosnUpldToDIMllmn));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    void IPCPSignalManager::setPassAirbDiReq(PassAirbDiReq& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PassAirbDiReq);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::OnOff2 IPCPSignalManager::getPassAirbSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassAirbSts));
        }
        if (signal.has_value()){
            return sdb::OnOff2(signal->value.int32Values[0]);
        }
        return sdb::OnOff2(-1);
    }

    sdb::PassSeatSts1 IPCPSignalManager::getPassSeatSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PassSeatSts));
        }
        if (signal.has_value()){
            return sdb::PassSeatSts1(signal->value.int32Values[0]);
        }
        return sdb::PassSeatSts1(-1);
    }

    float IPCPSignalManager::getADataRawSafeALat() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeALat));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getADataRawSafeALat1Qf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeALat1Qf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getADataRawSafeALgt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeALgt));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getADataRawSafeALgt1Qf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeALgt1Qf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getADataRawSafeAVert() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeAVert));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getADataRawSafeAVertQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeAVertQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    int32_t IPCPSignalManager::getADataRawSafeChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getADataRawSafeCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ADataRawSafeCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAgDataRawSafeChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getAgDataRawSafeCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getAgDataRawSafeRollRate() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeRollRate));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getAgDataRawSafeRollRateQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeRollRateQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    float IPCPSignalManager::getAgDataRawSafeYawRate() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeYawRate));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qf1 IPCPSignalManager::getAgDataRawSafeYawRateQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AgDataRawSafeYawRateQf));
        }
        if (signal.has_value()){
            return sdb::Qf1(signal->value.int32Values[0]);
        }
        return sdb::Qf1(-1);
    }

    sdb::BltLockSt1 IPCPSignalManager::getBltLockStAtDrvrBltLockSt1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BltLockStAtDrvrBltLockSt1));
        }
        if (signal.has_value()){
            return sdb::BltLockSt1(signal->value.int32Values[0]);
        }
        return sdb::BltLockSt1(-1);
    }

    sdb::DevErrSts2 IPCPSignalManager::getBltLockStAtDrvrBltLockSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BltLockStAtDrvrBltLockSts));
        }
        if (signal.has_value()){
            return sdb::DevErrSts2(signal->value.int32Values[0]);
        }
        return sdb::DevErrSts2(-1);
    }

    sdb::PsdNotPsd IPCPSignalManager::getSteerWhlLeBtn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlLeBtn));
        }
        if (signal.has_value()){
            return sdb::PsdNotPsd(signal->value.int32Values[0]);
        }
        return sdb::PsdNotPsd(-1);
    }

    void IPCPSignalManager::setAutoHldSoftSwtCtrlSt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutoHldSoftSwtCtrlSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChgPreSetTempButtonReq(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChgPreSetTempButtonReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChrgSoftSwCtrlSt(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChrgSoftSwCtrlSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setChrgStationPwr(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ChrgStationPwr);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDChaEngStsCtrl(sdb::IdleEnaDis value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DChaEngStsCtrl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDchaChrgnTarVal(float value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DchaChrgnTarVal);
        signal.value.floatValues={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDeactvtLvlgCtrl(sdb::Boolean value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DeactvtLvlgCtrl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEPedlModCtrlSt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EPedlModCtrlSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEgyRgnLvlSet(sdb::EgyRgnLvlSet value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EgyRgnLvlSet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEscSptModReqdByDrvr(EscSptModReqdByDrvr& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EscSptModReqdByDrvr);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setEstimdLeSocToDest(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::EstimdLeSocToDest);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHillDwnCtrlSt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HillDwnCtrlSt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLimdSpdReqForEcoMod(LimdSpdReqForEcoMod& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LimdSpdReqForEcoMod);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLnchModSwt(sdb::OnOffNoReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LnchModSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setLocalBookChrgnTarVal(float value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::LocalBookChrgnTarVal);
        signal.value.floatValues={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setMaintainBattTCtrl(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::MaintainBattTCtrl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setMaxAcInpCurrentSet(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::MaxAcInpCurrentSet);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPwrSavingMod(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PwrSavingMod);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSaveSetgToMemPrmnt(sdb::OffOnAut1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SaveSetgToMemPrmnt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setShowTypOfDTESet(sdb::ShowTyp1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ShowTypOfDTESet);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setSuspSetg(SuspSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::SuspSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTiToDestNavRoute(TiToDestNavRoute& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TiToDestNavRoute);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTypToDestNavRoute(sdb::LvlgSwtSetReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TypToDestNavRoute);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setV2XDchaSwt(sdb::DisChrgrSW value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::V2XDchaSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setVehDecelCtrlSetg(VehDecelCtrlSetg& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::VehDecelCtrlSetg);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    int32_t IPCPSignalManager::getVehSpdLgtTar() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLgtTar));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvSysRlyStsChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvSysRlyStsChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvSysRlyStsCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvSysRlyStsCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::HvActvnSts IPCPSignalManager::getHvSysRlyStsHvSysRlySts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvSysRlyStsHvSysRlySts));
        }
        if (signal.has_value()){
            return sdb::HvActvnSts(signal->value.int32Values[0]);
        }
        return sdb::HvActvnSts(-1);
    }

    sdb::AdjSpdLimnSts2 IPCPSignalManager::getAdjSpdLimnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AdjSpdLimnSts));
        }
        if (signal.has_value()){
            return sdb::AdjSpdLimnSts2(signal->value.int32Values[0]);
        }
        return sdb::AdjSpdLimnSts2(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getAutHldSoftSwtEnaSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutHldSoftSwtEnaSts));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::BookChargeSetResponse IPCPSignalManager::getBookChargeSetResponse() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BookChargeSetResponse));
        }
        if (signal.has_value()){
            return sdb::BookChargeSetResponse(signal->value.int32Values[0]);
        }
        return sdb::BookChargeSetResponse(-1);
    }

    float IPCPSignalManager::getBookChrgnTarValFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BookChrgnTarValFb));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::ChrgnSts2 IPCPSignalManager::getChrgnOrDisChrgnStsFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnOrDisChrgnStsFb));
        }
        if (signal.has_value()){
            return sdb::ChrgnSts2(signal->value.int32Values[0]);
        }
        return sdb::ChrgnSts2(-1);
    }

    int32_t IPCPSignalManager::getChrgnSpd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnSpd));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::ChrgnSts IPCPSignalManager::getChrgnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnSts));
        }
        if (signal.has_value()){
            return sdb::ChrgnSts(signal->value.int32Values[0]);
        }
        return sdb::ChrgnSts(-1);
    }

    sdb::CrsCtrlrSts1 IPCPSignalManager::getCrsCtrlrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CrsCtrlrSts));
        }
        if (signal.has_value()){
            return sdb::CrsCtrlrSts1(signal->value.int32Values[0]);
        }
        return sdb::CrsCtrlrSts1(-1);
    }

    sdb::ChrgrSts2 IPCPSignalManager::getDCChrgSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCChrgSt));
        }
        if (signal.has_value()){
            return sdb::ChrgrSts2(signal->value.int32Values[0]);
        }
        return sdb::ChrgrSts2(-1);
    }

    sdb::OnBdChrgrHndlSts IPCPSignalManager::getDCChrgnHndlSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCChrgnHndlSts));
        }
        if (signal.has_value()){
            return sdb::OnBdChrgrHndlSts(signal->value.int32Values[0]);
        }
        return sdb::OnBdChrgrHndlSts(-1);
    }

    float IPCPSignalManager::getDchaChrgnTarValFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaChrgnTarValFb));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDchaEgyAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaEgyAct));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDchaIAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaIAct));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::ReqSts1 IPCPSignalManager::getDchaStopByTarDrvrIndcn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaStopByTarDrvrIndcn));
        }
        if (signal.has_value()){
            return sdb::ReqSts1(signal->value.int32Values[0]);
        }
        return sdb::ReqSts1(-1);
    }

    float IPCPSignalManager::getDchaUAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaUAct));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDispHvBattLvlOfChrg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DispHvBattLvlOfChrg));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::DispOfPrpsnModForEv IPCPSignalManager::getDispOfPrpsnModForEv() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DispOfPrpsnModForEv));
        }
        if (signal.has_value()){
            return sdb::DispOfPrpsnModForEv(signal->value.int32Values[0]);
        }
        return sdb::DispOfPrpsnModForEv(-1);
    }

    int32_t IPCPSignalManager::getDstEstimdToEmptyForDrvgElec() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DstEstimdToEmptyForDrvgElec));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDstEstimdToEmptyForDrvgElecPred() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DstEstimdToEmptyForDrvgElecPred));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDstEstimdToEmptyForTarSoc1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DstEstimdToEmptyForTarSoc1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDstEstimdToEmptyForTarSoc2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DstEstimdToEmptyForTarSoc2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DstFromDestinationResp IPCPSignalManager::getDstFromDestinationFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DstFromDestinationFb));
        }
        if (signal.has_value()){
            return sdb::DstFromDestinationResp(signal->value.int32Values[0]);
        }
        return sdb::DstFromDestinationResp(-1);
    }

    sdb::IndcnMsg IPCPSignalManager::getEPedlDrvrIndcnMsg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EPedlDrvrIndcnMsg));
        }
        if (signal.has_value()){
            return sdb::IndcnMsg(signal->value.int32Values[0]);
        }
        return sdb::IndcnMsg(-1);
    }

    sdb::Boolean IPCPSignalManager::getEPedlInhbnSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EPedlInhbnSts));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::CrsCtrlrSts1 IPCPSignalManager::getEPedlModSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EPedlModSts));
        }
        if (signal.has_value()){
            return sdb::CrsCtrlrSts1(signal->value.int32Values[0]);
        }
        return sdb::CrsCtrlrSts1(-1);
    }

    sdb::EgyRgnLvlSet IPCPSignalManager::getEgyRgnLvlAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EgyRgnLvlAct));
        }
        if (signal.has_value()){
            return sdb::EgyRgnLvlSet(signal->value.int32Values[0]);
        }
        return sdb::EgyRgnLvlSet(-1);
    }

    sdb::YesNo2 IPCPSignalManager::getEpbApplyEna() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EpbApplyEna));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    sdb::YesNo2 IPCPSignalManager::getEpbRelsEna() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EpbRelsEna));
        }
        if (signal.has_value()){
            return sdb::YesNo2(signal->value.int32Values[0]);
        }
        return sdb::YesNo2(-1);
    }

    sdb::DevSts1 IPCPSignalManager::getEscCtrlIndcn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EscCtrlIndcn));
        }
        if (signal.has_value()){
            return sdb::DevSts1(signal->value.int32Values[0]);
        }
        return sdb::DevSts1(-1);
    }

    sdb::GearLvrIndcn2 IPCPSignalManager::getGearLvrIndcn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::GearLvrIndcn));
        }
        if (signal.has_value()){
            return sdb::GearLvrIndcn2(signal->value.int32Values[0]);
        }
        return sdb::GearLvrIndcn2(-1);
    }

    float IPCPSignalManager::getHvBattCap() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattCap));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvBattChrgnTiEstimd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattChrgnTiEstimd));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvBattDchaTiEstimd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattDchaTiEstimd));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHvBattIDc1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattIDc1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvBattLimnIndcn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattLimnIndcn));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::ThermSts1 IPCPSignalManager::getHvBattSupChrgThermSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattSupChrgThermSts));
        }
        if (signal.has_value()){
            return sdb::ThermSts1(signal->value.int32Values[0]);
        }
        return sdb::ThermSts1(-1);
    }

    int32_t IPCPSignalManager::getHvBattThermPwrCns() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattThermPwrCns));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHvBattUDc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattUDc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvCabinThermPwrCns() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvCabinThermPwrCns));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getIDcDcActHiSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IDcDcActHiSide));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getIsgUDc800() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IsgUDc800));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::LaunchModeIndcn IPCPSignalManager::getLnchModIndcnMsg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LnchModIndcnMsg));
        }
        if (signal.has_value()){
            return sdb::LaunchModeIndcn(signal->value.int32Values[0]);
        }
        return sdb::LaunchModeIndcn(-1);
    }

    sdb::LnchMode IPCPSignalManager::getLnchModSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LnchModSts));
        }
        if (signal.has_value()){
            return sdb::LnchMode(signal->value.int32Values[0]);
        }
        return sdb::LnchMode(-1);
    }

    sdb::BookChrgnStsFb IPCPSignalManager::getMaintainBattTFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MaintainBattTFb));
        }
        if (signal.has_value()){
            return sdb::BookChrgnStsFb(signal->value.int32Values[0]);
        }
        return sdb::BookChrgnStsFb(-1);
    }

    int32_t IPCPSignalManager::getMaxACInpISetFdb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MaxACInpISetFdb));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::MsgReqByHillDwnCtrl1 IPCPSignalManager::getMsgReqByHillDwnCtrl() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MsgReqByHillDwnCtrl));
        }
        if (signal.has_value()){
            return sdb::MsgReqByHillDwnCtrl1(signal->value.int32Values[0]);
        }
        return sdb::MsgReqByHillDwnCtrl1(-1);
    }

    sdb::OnBdChrgrHndlSts1 IPCPSignalManager::getOnBdChrgrHndlSts1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrHndlSts1));
        }
        if (signal.has_value()){
            return sdb::OnBdChrgrHndlSts1(signal->value.int32Values[0]);
        }
        return sdb::OnBdChrgrHndlSts1(-1);
    }

    float IPCPSignalManager::getOnBdChrgrIAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrIAct));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::ChrgrSts1 IPCPSignalManager::getOnBdChrgrSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrSt));
        }
        if (signal.has_value()){
            return sdb::ChrgrSts1(signal->value.int32Values[0]);
        }
        return sdb::ChrgrSts1(-1);
    }

    float IPCPSignalManager::getOnBdChrgrUAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrUAct));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Typ1 IPCPSignalManager::getPrpsnModElecDrvBlkd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrpsnModElecDrvBlkd));
        }
        if (signal.has_value()){
            return sdb::Typ1(signal->value.int32Values[0]);
        }
        return sdb::Typ1(-1);
    }

    sdb::Typ1 IPCPSignalManager::getPrpsnModOfTracBlkd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrpsnModOfTracBlkd));
        }
        if (signal.has_value()){
            return sdb::Typ1(signal->value.int32Values[0]);
        }
        return sdb::Typ1(-1);
    }

    sdb::Typ1 IPCPSignalManager::getPrpsnModOffroadBlkd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrpsnModOffroadBlkd));
        }
        if (signal.has_value()){
            return sdb::Typ1(signal->value.int32Values[0]);
        }
        return sdb::Typ1(-1);
    }

    sdb::Typ1 IPCPSignalManager::getPrpsnModSptBlkd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrpsnModSptBlkd));
        }
        if (signal.has_value()){
            return sdb::Typ1(signal->value.int32Values[0]);
        }
        return sdb::Typ1(-1);
    }

    sdb::PtGearAct1 IPCPSignalManager::getPtGearAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtGearAct));
        }
        if (signal.has_value()){
            return sdb::PtGearAct1(signal->value.int32Values[0]);
        }
        return sdb::PtGearAct1(-1);
    }

    sdb::SteerErrReq3 IPCPSignalManager::getSteerErrReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerErrReq));
        }
        if (signal.has_value()){
            return sdb::SteerErrReq3(signal->value.int32Values[0]);
        }
        return sdb::SteerErrReq3(-1);
    }

    sdb::EnableDisableCoding IPCPSignalManager::getSwtStsforHillDwnCtrl() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SwtStsforHillDwnCtrl));
        }
        if (signal.has_value()){
            return sdb::EnableDisableCoding(signal->value.int32Values[0]);
        }
        return sdb::EnableDisableCoding(-1);
    }

    sdb::DisChrgrSW IPCPSignalManager::getV2XDchaSwtFb1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::V2XDchaSwtFb1));
        }
        if (signal.has_value()){
            return sdb::DisChrgrSW(signal->value.int32Values[0]);
        }
        return sdb::DisChrgrSW(-1);
    }

    int32_t IPCPSignalManager::getV2XDchaSwtFdb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::V2XDchaSwtFdb));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getWhlMotSysIdc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlMotSysIdc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getBrkFricTqAtWhlActBrkFricTqAtWhlFrntLeAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkFricTqAtWhlActBrkFricTqAtWhlFrntLeAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getBrkFricTqAtWhlActBrkFricTqAtWhlFrntRiAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkFricTqAtWhlActBrkFricTqAtWhlFrntRiAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getBrkFricTqAtWhlActBrkFricTqAtWhlReLeAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkFricTqAtWhlActBrkFricTqAtWhlReLeAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getBrkFricTqAtWhlActBrkFricTqAtWhlReRiAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkFricTqAtWhlActBrkFricTqAtWhlReRiAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDchaEgyStrgDchaCarTiGlb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaEgyStrgDchaCarTiGlb));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDchaEgyStrgDchaEgy() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaEgyStrgDchaEgy));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDrvrDesDirChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrDesDirChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDrvrDesDirCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrDesDirCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::DrvrDesDir1 IPCPSignalManager::getDrvrDesDirDrvrDesDir() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrDesDirDrvrDesDir));
        }
        if (signal.has_value()){
            return sdb::DrvrDesDir1(signal->value.int32Values[0]);
        }
        return sdb::DrvrDesDir1(-1);
    }

    sdb::EscSt1 IPCPSignalManager::getEscStEscSt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EscStEscSt));
        }
        if (signal.has_value()){
            return sdb::EscSt1(signal->value.int32Values[0]);
        }
        return sdb::EscSt1(-1);
    }

    int32_t IPCPSignalManager::getIDcDcActLoSideChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IDcDcActLoSideChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getIDcDcActLoSideCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IDcDcActLoSideCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getIDcDcActLoSideIDcDcActLoSide() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IDcDcActLoSideIDcDcActLoSide));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qly2 IPCPSignalManager::getPitchAgGlbQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PitchAgGlbQf));
        }
        if (signal.has_value()){
            return sdb::Qly2(signal->value.int32Values[0]);
        }
        return sdb::Qly2(-1);
    }

    float IPCPSignalManager::getPitchAgGlbVal() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PitchAgGlbVal));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlFrntActChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlFrntActCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlFrntActPtTqAtAxleFrntAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActPtTqAtAxleFrntAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlFrntActPtTqAtWhlFrntLeAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActPtTqAtWhlFrntLeAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlFrntActPtTqAtWhlFrntRiAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActPtTqAtWhlFrntRiAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qly3 IPCPSignalManager::getPtTqAtWhlFrntActPtTqAtWhlsFrntQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlFrntActPtTqAtWhlsFrntQly));
        }
        if (signal.has_value()){
            return sdb::Qly3(signal->value.int32Values[0]);
        }
        return sdb::Qly3(-1);
    }

    int32_t IPCPSignalManager::getPtTqAtWhlReActChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlReActCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlReActPtTqAtAxleReAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActPtTqAtAxleReAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlReActPtTqAtWhlReLeAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActPtTqAtWhlReLeAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getPtTqAtWhlReActPtTqAtWhlReRiAct() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActPtTqAtWhlReRiAct));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qly3 IPCPSignalManager::getPtTqAtWhlReActPtTqAtWhlsReQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PtTqAtWhlReActPtTqAtWhlsReQly));
        }
        if (signal.has_value()){
            return sdb::Qly3(signal->value.int32Values[0]);
        }
        return sdb::Qly3(-1);
    }

    sdb::Qly2 IPCPSignalManager::getRoadInclnQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RoadInclnQly));
        }
        if (signal.has_value()){
            return sdb::Qly2(signal->value.int32Values[0]);
        }
        return sdb::Qly2(-1);
    }

    float IPCPSignalManager::getRoadInclnRoadIncln() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RoadInclnRoadIncln));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Qly2 IPCPSignalManager::getRollAgGlbQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RollAgGlbQf));
        }
        if (signal.has_value()){
            return sdb::Qly2(signal->value.int32Values[0]);
        }
        return sdb::Qly2(-1);
    }

    float IPCPSignalManager::getRollAgGlbVal() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RollAgGlbVal));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopReducEngCoeffSlopEqu12() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopReducEngCoeffSlopEqu12));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopReducEngCoeffSlopEqu2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopReducEngCoeffSlopEqu2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopReducEngCoeffSlopEqu4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopReducEngCoeffSlopEqu4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopReducEngCoeffSlopEqu6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopReducEngCoeffSlopEqu6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopReducEngCoeffSlopEqu9() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopReducEngCoeffSlopEqu9));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopRiseEngCoeffSlopEqu12() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopRiseEngCoeffSlopEqu12));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopRiseEngCoeffSlopEqu2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopRiseEngCoeffSlopEqu2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopRiseEngCoeffSlopEqu4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopRiseEngCoeffSlopEqu4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopRiseEngCoeffSlopEqu6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopRiseEngCoeffSlopEqu6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSlopRiseEngCoeffSlopEqu9() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SlopRiseEngCoeffSlopEqu9));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu10() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu10));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu100() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu100));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu120() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu120));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu140() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu140));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu20() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu20));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu40() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu40));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu60() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu60));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSpdRelatWghtSpdEqu80() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SpdRelatWghtSpdEqu80));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getSteerWhlSnsrAg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlSnsrAg));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getSteerWhlSnsrAgSpd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlSnsrAgSpd));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSteerWhlSnsrChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlSnsrChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSteerWhlSnsrCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlSnsrCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getSteerWhlSnsrQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerWhlSnsrQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    int32_t IPCPSignalManager::getSuspFailrStsChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspFailrStsChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getSuspFailrStsCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspFailrStsCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::SuspFailrStsTyp2 IPCPSignalManager::getSuspFailrStsSuspFailrSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspFailrStsSuspFailrSts));
        }
        if (signal.has_value()){
            return sdb::SuspFailrStsTyp2(signal->value.int32Values[0]);
        }
        return sdb::SuspFailrStsTyp2(-1);
    }

    sdb::GenQf1 IPCPSignalManager::getSuspFailrStsTypQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspFailrStsTypQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    int32_t IPCPSignalManager::getSuspPosnVertLe1Chks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertLe1Chks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getSuspPosnVertLe1Frnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertLe1Frnt));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getSuspPosnVertLe1FrntQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertLe1FrntQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    float IPCPSignalManager::getSuspPosnVertLe1Re() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertLe1Re));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getSuspPosnVertLe1ReQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertLe1ReQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    int32_t IPCPSignalManager::getSuspPosnVertRi1SuspPosnVertRiChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertRi1SuspPosnVertRiChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getSuspPosnVertRi1SuspPosnVertRiFrnt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertRi1SuspPosnVertRiFrnt));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getSuspPosnVertRi1SuspPosnVertRiFrntQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertRi1SuspPosnVertRiFrntQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    float IPCPSignalManager::getSuspPosnVertRi1SuspPosnVertRiRe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertRi1SuspPosnVertRiRe));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getSuspPosnVertRi1SuspPosnVertRiReQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SuspPosnVertRi1SuspPosnVertRiReQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    sdb::TrlrM IPCPSignalManager::getVehMNomTrlrM() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMNomTrlrM));
        }
        if (signal.has_value()){
            return sdb::TrlrM(signal->value.int32Values[0]);
        }
        return sdb::TrlrM(-1);
    }

    int32_t IPCPSignalManager::getVehMNomVehM() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMNomVehM));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::Qly2 IPCPSignalManager::getVehMNomVehMQly() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMNomVehMQly));
        }
        if (signal.has_value()){
            return sdb::Qly2(signal->value.int32Values[0]);
        }
        return sdb::Qly2(-1);
    }

    int32_t IPCPSignalManager::getVehMtnStChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMtnStChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehMtnStCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehMtnStCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getVehSpdLgtA() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLgtA));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehSpdLgtChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLgtChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getVehSpdLgtCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLgtCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getVehSpdLgtQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::VehSpdLgtQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrFrntLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrFrntLe));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrFrntRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrFrntRi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrReLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrReLe));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlRotToothCntrReRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlRotToothCntrReRi));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlSpdCircumlFrntChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlSpdCircumlFrntCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getWhlSpdCircumlFrntLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntLe));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getWhlSpdCircumlFrntLeQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntLeQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    sdb::GenQf1 IPCPSignalManager::getWhlSpdCircumlFrntRiQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntRiQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    float IPCPSignalManager::getWhlSpdCircumlFrntWhlSpdCircumlFrntRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlFrntWhlSpdCircumlFrntRi));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlSpdCircumlReChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getWhlSpdCircumlReCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getWhlSpdCircumlReLe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReLe));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getWhlSpdCircumlReLeQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReLeQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    float IPCPSignalManager::getWhlSpdCircumlReRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReRi));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getWhlSpdCircumlReRiQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WhlSpdCircumlReRiQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getChgPreSetTempButtonFb() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChgPreSetTempButtonFb));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::Boolean IPCPSignalManager::getChgPreSetTempButtonInhibit() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChgPreSetTempButtonInhibit));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    float IPCPSignalManager::getDCDCPwrCns1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCDCPwrCns1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDCDCPwrCns2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCDCPwrCns2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDCDCPwrCns3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCDCPwrCns3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDynEgyCons1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DynEgyCons1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDynEgyCons2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DynEgyCons2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getDynEgyCons3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DynEgyCons3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHVBatteryThermPwrCns1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HVBatteryThermPwrCns1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHVBatteryThermPwrCns2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HVBatteryThermPwrCns2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHVBatteryThermPwrCns3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HVBatteryThermPwrCns3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getHvBattEgyAvlDcha1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattEgyAvlDcha1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::OnOffNoReq IPCPSignalManager::getHvBattOptmzHint() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattOptmzHint));
        }
        if (signal.has_value()){
            return sdb::OnOffNoReq(signal->value.int32Values[0]);
        }
        return sdb::OnOffNoReq(-1);
    }

    sdb::OkNotOk IPCPSignalManager::getHvBattTempSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattTempSts));
        }
        if (signal.has_value()){
            return sdb::OkNotOk(signal->value.int32Values[0]);
        }
        return sdb::OkNotOk(-1);
    }

    float IPCPSignalManager::getHvCabinThermPwrCns1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvCabinThermPwrCns1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHvCabinThermPwrCns2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvCabinThermPwrCns2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getHvCabinThermPwrCns3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvCabinThermPwrCns3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getMotSysPowCnsUIdc1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MotSysPowCnsUIdc1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getMotSysPowCnsUIdc2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MotSysPowCnsUIdc2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getMotSysPowCnsUIdc3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MotSysPowCnsUIdc3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::FltIndn IPCPSignalManager::getThermalSystemRedn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ThermalSystemRedn));
        }
        if (signal.has_value()){
            return sdb::FltIndn(signal->value.int32Values[0]);
        }
        return sdb::FltIndn(-1);
    }

    float IPCPSignalManager::getTotEngCons1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TotEngCons1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getTotEngCons2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TotEngCons2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getTotEngCons3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TotEngCons3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getV2XPwrCns1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::V2XPwrCns1));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getV2XPwrCns2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::V2XPwrCns2));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    float IPCPSignalManager::getV2XPwrCns3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::V2XPwrCns3));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::NoYes1 IPCPSignalManager::getBrkPedlPsdBrkPedlNotPsdSafe() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkPedlPsdBrkPedlNotPsdSafe));
        }
        if (signal.has_value()){
            return sdb::NoYes1(signal->value.int32Values[0]);
        }
        return sdb::NoYes1(-1);
    }

    sdb::NoYes1 IPCPSignalManager::getBrkPedlPsdBrkPedlPsd() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkPedlPsdBrkPedlPsd));
        }
        if (signal.has_value()){
            return sdb::NoYes1(signal->value.int32Values[0]);
        }
        return sdb::NoYes1(-1);
    }

    int32_t IPCPSignalManager::getBrkPedlPsdChks() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkPedlPsdChks));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getBrkPedlPsdCntr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkPedlPsdCntr));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    sdb::GenQf1 IPCPSignalManager::getBrkPedlPsdQf() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkPedlPsdQf));
        }
        if (signal.has_value()){
            return sdb::GenQf1(signal->value.int32Values[0]);
        }
        return sdb::GenQf1(-1);
    }

    void IPCPSignalManager::setAutoOpenSwtHmiReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::AutoOpenSwtHmiReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDataUploadPermisn(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DataUploadPermisn);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDigKeyDataToRemCtrl(DigKeyDataToRemCtrl& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DigKeyDataToRemCtrl);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setDstEstimdToEmptyForDrvgElecIndcd(DstEstimdToEmptyForDrvgElecIndcd& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::DstEstimdToEmptyForDrvgElecIndcd);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setExtLiFileTrfCdnSts(sdb::ActvnWithMsg value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ExtLiFileTrfCdnSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setExtLifileSndSts(sdb::ActvnWithMsg value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::ExtLifileSndSts);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiCarLocatorSetReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiCarLocatorSetReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiClimaFrntAutReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiClimaFrntAutReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiCmptmtAirDistbnFrntLe(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiCmptmtAirDistbnFrntLe);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiCmptmtAirDistbnFrntRi(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiCmptmtAirDistbnFrntRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiDefrstMaxReq(sdb::ActrReq value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiDefrstMaxReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setHmiResetTcamReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::HmiResetTcamReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setIndcnUnit(IndcnUnit& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::IndcnUnit);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setNetIHUActvt(NetIHUActvt& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::NetIHUActvt);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setPrkgCmftRunRmnReq(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::PrkgCmftRunRmnReq);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setTotEngConsPerDay(float value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::TotEngConsPerDay);
        signal.value.floatValues={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setWirelschrgActvReqFromHmi(sdb::PsdNotPsd value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(SignalTX::WirelschrgActvReqFromHmi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    sdb::ActvnAvl3 IPCPSignalManager::getCarLocatorActvSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarLocatorActvSts));
        }
        if (signal.has_value()){
            return sdb::ActvnAvl3(signal->value.int32Values[0]);
        }
        return sdb::ActvnAvl3(-1);
    }

    sdb::BookChrgnResp IPCPSignalManager::getBookChrgnResp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BookChrgnResp));
        }
        if (signal.has_value()){
            return sdb::BookChrgnResp(signal->value.int32Values[0]);
        }
        return sdb::BookChrgnResp(-1);
    }

    sdb::OnOff1 IPCPSignalManager::getCarLocatorSetResp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarLocatorSetResp));
        }
        if (signal.has_value()){
            return sdb::OnOff1(signal->value.int32Values[0]);
        }
        return sdb::OnOff1(-1);
    }

    sdb::DigKeyReqStatus IPCPSignalManager::getDigKeyReqSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyReqSts));
        }
        if (signal.has_value()){
            return sdb::DigKeyReqStatus(signal->value.int32Values[0]);
        }
        return sdb::DigKeyReqStatus(-1);
    }

    sdb::VentnActr01BlckInd IPCPSignalManager::getIntelliClimaEgySaveReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::IntelliClimaEgySaveReq));
        }
        if (signal.has_value()){
            return sdb::VentnActr01BlckInd(signal->value.int32Values[0]);
        }
        return sdb::VentnActr01BlckInd(-1);
    }

    sdb::Boolean IPCPSignalManager::getPhoneForgottenRmn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PhoneForgottenRmn));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::Boolean IPCPSignalManager::getPhoneForgottenRmnBNCM2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PhoneForgottenRmnBNCM2));
        }
        if (signal.has_value()){
            return sdb::Boolean(signal->value.int32Values[0]);
        }
        return sdb::Boolean(-1);
    }

    sdb::OnOffNoReq IPCPSignalManager::getPrkgCmftModTiCtrlReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::PrkgCmftModTiCtrlReq));
        }
        if (signal.has_value()){
            return sdb::OnOffNoReq(signal->value.int32Values[0]);
        }
        return sdb::OnOffNoReq(-1);
    }

    sdb::ReqSts1 IPCPSignalManager::getRemFileDownloadReq() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RemFileDownloadReq));
        }
        if (signal.has_value()){
            return sdb::ReqSts1(signal->value.int32Values[0]);
        }
        return sdb::ReqSts1(-1);
    }

    sdb::SuccessFailNoResp IPCPSignalManager::getTcamResetResp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TcamResetResp));
        }
        if (signal.has_value()){
            return sdb::SuccessFailNoResp(signal->value.int32Values[0]);
        }
        return sdb::SuccessFailNoResp(-1);
    }

    sdb::WPCModuleSts IPCPSignalManager::getWPCModuleSts() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WPCModuleSts));
        }
        if (signal.has_value()){
            return sdb::WPCModuleSts(signal->value.int32Values[0]);
        }
        return sdb::WPCModuleSts(-1);
    }

    sdb::WPCModuleSts IPCPSignalManager::getWPCModuleStsBNCM2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WPCModuleStsBNCM2));
        }
        if (signal.has_value()){
            return sdb::WPCModuleSts(signal->value.int32Values[0]);
        }
        return sdb::WPCModuleSts(-1);
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIAcknowledgment() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIAcknowledgment));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte3));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte5));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIDKDataByte6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIDKDataByte6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyDataToHMIHeader() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyDataToHMIHeader));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte0));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte3));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte5));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo1Byte7() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo1Byte7));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte0));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte1));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte2));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte3));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte4));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte5));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte6));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    int32_t IPCPSignalManager::getDigKeyGidInfo2Byte7() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DigKeyGidInfo2Byte7));
        }
        if (signal.has_value()){
            return signal->value.int32Values[0];
        }
        return -1;
    }

    float IPCPSignalManager::getWirelsChrgnPhonePwrPerc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WirelsChrgnPhonePwrPerc));
        }
        if (signal.has_value()){
            return signal->value.floatValues[0];
        }
        return -1;
    }

    sdb::Carconfig0 IPCPSignalManager::getcarconfig0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig0));
        }
        if (signal.has_value()){
            return sdb::Carconfig0(signal->value.int32Values[0]);
        }
        return sdb::Carconfig0(-1);
    }

    sdb::CarConfig1 IPCPSignalManager::getcarconfig1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1));
        }
        if (signal.has_value()){
            return sdb::CarConfig1(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1(-1);
    }

    sdb::CarConfig2 IPCPSignalManager::getcarconfig2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig2));
        }
        if (signal.has_value()){
            return sdb::CarConfig2(signal->value.int32Values[0]);
        }
        return sdb::CarConfig2(-1);
    }

    sdb::CarConfig3 IPCPSignalManager::getcarconfig3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig3));
        }
        if (signal.has_value()){
            return sdb::CarConfig3(signal->value.int32Values[0]);
        }
        return sdb::CarConfig3(-1);
    }

    sdb::CarConfig4 IPCPSignalManager::getcarconfig4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig4));
        }
        if (signal.has_value()){
            return sdb::CarConfig4(signal->value.int32Values[0]);
        }
        return sdb::CarConfig4(-1);
    }

    sdb::CarConfig5 IPCPSignalManager::getcarconfig5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig5));
        }
        if (signal.has_value()){
            return sdb::CarConfig5(signal->value.int32Values[0]);
        }
        return sdb::CarConfig5(-1);
    }

    sdb::CarConfig6 IPCPSignalManager::getcarconfig6() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig6));
        }
        if (signal.has_value()){
            return sdb::CarConfig6(signal->value.int32Values[0]);
        }
        return sdb::CarConfig6(-1);
    }

    sdb::Carconfig7 IPCPSignalManager::getcarconfig7() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig7));
        }
        if (signal.has_value()){
            return sdb::Carconfig7(signal->value.int32Values[0]);
        }
        return sdb::Carconfig7(-1);
    }

    sdb::CarConfig8 IPCPSignalManager::getcarconfig8() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig8));
        }
        if (signal.has_value()){
            return sdb::CarConfig8(signal->value.int32Values[0]);
        }
        return sdb::CarConfig8(-1);
    }

    sdb::CarConfig9 IPCPSignalManager::getcarconfig9() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig9));
        }
        if (signal.has_value()){
            return sdb::CarConfig9(signal->value.int32Values[0]);
        }
        return sdb::CarConfig9(-1);
    }

    sdb::CarConfig10 IPCPSignalManager::getcarconfig10() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig10));
        }
        if (signal.has_value()){
            return sdb::CarConfig10(signal->value.int32Values[0]);
        }
        return sdb::CarConfig10(-1);
    }

    sdb::CarConfig11 IPCPSignalManager::getcarconfig11() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig11));
        }
        if (signal.has_value()){
            return sdb::CarConfig11(signal->value.int32Values[0]);
        }
        return sdb::CarConfig11(-1);
    }

    sdb::CarConfig12 IPCPSignalManager::getcarconfig12() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig12));
        }
        if (signal.has_value()){
            return sdb::CarConfig12(signal->value.int32Values[0]);
        }
        return sdb::CarConfig12(-1);
    }

    sdb::CarConfig13 IPCPSignalManager::getcarconfig13() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig13));
        }
        if (signal.has_value()){
            return sdb::CarConfig13(signal->value.int32Values[0]);
        }
        return sdb::CarConfig13(-1);
    }

    sdb::Carconfig14 IPCPSignalManager::getcarconfig14() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig14));
        }
        if (signal.has_value()){
            return sdb::Carconfig14(signal->value.int32Values[0]);
        }
        return sdb::Carconfig14(-1);
    }

    sdb::Carconfig15 IPCPSignalManager::getcarconfig15() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig15));
        }
        if (signal.has_value()){
            return sdb::Carconfig15(signal->value.int32Values[0]);
        }
        return sdb::Carconfig15(-1);
    }

    sdb::CarConfig16 IPCPSignalManager::getcarconfig16() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig16));
        }
        if (signal.has_value()){
            return sdb::CarConfig16(signal->value.int32Values[0]);
        }
        return sdb::CarConfig16(-1);
    }

    sdb::Carconfig17 IPCPSignalManager::getcarconfig17() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig17));
        }
        if (signal.has_value()){
            return sdb::Carconfig17(signal->value.int32Values[0]);
        }
        return sdb::Carconfig17(-1);
    }

    sdb::CarConfig18 IPCPSignalManager::getcarconfig18() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig18));
        }
        if (signal.has_value()){
            return sdb::CarConfig18(signal->value.int32Values[0]);
        }
        return sdb::CarConfig18(-1);
    }

    sdb::CarConfig19 IPCPSignalManager::getcarconfig19() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig19));
        }
        if (signal.has_value()){
            return sdb::CarConfig19(signal->value.int32Values[0]);
        }
        return sdb::CarConfig19(-1);
    }

    sdb::Carconfig20 IPCPSignalManager::getcarconfig20() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig20));
        }
        if (signal.has_value()){
            return sdb::Carconfig20(signal->value.int32Values[0]);
        }
        return sdb::Carconfig20(-1);
    }

    sdb::Carconfig21 IPCPSignalManager::getcarconfig21() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig21));
        }
        if (signal.has_value()){
            return sdb::Carconfig21(signal->value.int32Values[0]);
        }
        return sdb::Carconfig21(-1);
    }

    sdb::CarConfig22 IPCPSignalManager::getcarconfig22() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig22));
        }
        if (signal.has_value()){
            return sdb::CarConfig22(signal->value.int32Values[0]);
        }
        return sdb::CarConfig22(-1);
    }

    sdb::CarConfig23 IPCPSignalManager::getcarconfig23() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig23));
        }
        if (signal.has_value()){
            return sdb::CarConfig23(signal->value.int32Values[0]);
        }
        return sdb::CarConfig23(-1);
    }

    sdb::CarConfig24 IPCPSignalManager::getcarconfig24() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig24));
        }
        if (signal.has_value()){
            return sdb::CarConfig24(signal->value.int32Values[0]);
        }
        return sdb::CarConfig24(-1);
    }

    sdb::CarConfig25 IPCPSignalManager::getcarconfig25() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig25));
        }
        if (signal.has_value()){
            return sdb::CarConfig25(signal->value.int32Values[0]);
        }
        return sdb::CarConfig25(-1);
    }

    sdb::Carconfig26 IPCPSignalManager::getcarconfig26() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig26));
        }
        if (signal.has_value()){
            return sdb::Carconfig26(signal->value.int32Values[0]);
        }
        return sdb::Carconfig26(-1);
    }

    sdb::Carconfig27 IPCPSignalManager::getcarconfig27() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig27));
        }
        if (signal.has_value()){
            return sdb::Carconfig27(signal->value.int32Values[0]);
        }
        return sdb::Carconfig27(-1);
    }

    sdb::Carconfig28 IPCPSignalManager::getcarconfig28() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig28));
        }
        if (signal.has_value()){
            return sdb::Carconfig28(signal->value.int32Values[0]);
        }
        return sdb::Carconfig28(-1);
    }

    sdb::CarConfig29 IPCPSignalManager::getcarconfig29() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig29));
        }
        if (signal.has_value()){
            return sdb::CarConfig29(signal->value.int32Values[0]);
        }
        return sdb::CarConfig29(-1);
    }

    sdb::Carconfig30 IPCPSignalManager::getcarconfig30() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig30));
        }
        if (signal.has_value()){
            return sdb::Carconfig30(signal->value.int32Values[0]);
        }
        return sdb::Carconfig30(-1);
    }

    sdb::Carconfig31 IPCPSignalManager::getcarconfig31() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig31));
        }
        if (signal.has_value()){
            return sdb::Carconfig31(signal->value.int32Values[0]);
        }
        return sdb::Carconfig31(-1);
    }

    sdb::Carconfig32 IPCPSignalManager::getcarconfig32() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig32));
        }
        if (signal.has_value()){
            return sdb::Carconfig32(signal->value.int32Values[0]);
        }
        return sdb::Carconfig32(-1);
    }

    sdb::Carconfig33 IPCPSignalManager::getcarconfig33() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig33));
        }
        if (signal.has_value()){
            return sdb::Carconfig33(signal->value.int32Values[0]);
        }
        return sdb::Carconfig33(-1);
    }

    sdb::Carconfig34 IPCPSignalManager::getcarconfig34() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig34));
        }
        if (signal.has_value()){
            return sdb::Carconfig34(signal->value.int32Values[0]);
        }
        return sdb::Carconfig34(-1);
    }

    sdb::Carconfig35 IPCPSignalManager::getcarconfig35() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig35));
        }
        if (signal.has_value()){
            return sdb::Carconfig35(signal->value.int32Values[0]);
        }
        return sdb::Carconfig35(-1);
    }

    sdb::CarConfig36 IPCPSignalManager::getcarconfig36() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig36));
        }
        if (signal.has_value()){
            return sdb::CarConfig36(signal->value.int32Values[0]);
        }
        return sdb::CarConfig36(-1);
    }

    sdb::Carconfig37 IPCPSignalManager::getcarconfig37() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig37));
        }
        if (signal.has_value()){
            return sdb::Carconfig37(signal->value.int32Values[0]);
        }
        return sdb::Carconfig37(-1);
    }

    sdb::Carconfig38 IPCPSignalManager::getcarconfig38() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig38));
        }
        if (signal.has_value()){
            return sdb::Carconfig38(signal->value.int32Values[0]);
        }
        return sdb::Carconfig38(-1);
    }

    sdb::CarConfig39 IPCPSignalManager::getcarconfig39() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig39));
        }
        if (signal.has_value()){
            return sdb::CarConfig39(signal->value.int32Values[0]);
        }
        return sdb::CarConfig39(-1);
    }

    sdb::Carconfig40 IPCPSignalManager::getcarconfig40() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig40));
        }
        if (signal.has_value()){
            return sdb::Carconfig40(signal->value.int32Values[0]);
        }
        return sdb::Carconfig40(-1);
    }

    sdb::CarConfig41 IPCPSignalManager::getcarconfig41() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig41));
        }
        if (signal.has_value()){
            return sdb::CarConfig41(signal->value.int32Values[0]);
        }
        return sdb::CarConfig41(-1);
    }

    sdb::Carconfig42 IPCPSignalManager::getcarconfig42() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig42));
        }
        if (signal.has_value()){
            return sdb::Carconfig42(signal->value.int32Values[0]);
        }
        return sdb::Carconfig42(-1);
    }

    sdb::CarConfig43 IPCPSignalManager::getcarconfig43() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig43));
        }
        if (signal.has_value()){
            return sdb::CarConfig43(signal->value.int32Values[0]);
        }
        return sdb::CarConfig43(-1);
    }

    sdb::CarConfig44 IPCPSignalManager::getcarconfig44() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig44));
        }
        if (signal.has_value()){
            return sdb::CarConfig44(signal->value.int32Values[0]);
        }
        return sdb::CarConfig44(-1);
    }

    sdb::Carconfig45 IPCPSignalManager::getcarconfig45() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig45));
        }
        if (signal.has_value()){
            return sdb::Carconfig45(signal->value.int32Values[0]);
        }
        return sdb::Carconfig45(-1);
    }

    sdb::Carconfig46 IPCPSignalManager::getcarconfig46() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig46));
        }
        if (signal.has_value()){
            return sdb::Carconfig46(signal->value.int32Values[0]);
        }
        return sdb::Carconfig46(-1);
    }

    sdb::CarConfig47 IPCPSignalManager::getcarconfig47() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig47));
        }
        if (signal.has_value()){
            return sdb::CarConfig47(signal->value.int32Values[0]);
        }
        return sdb::CarConfig47(-1);
    }

    sdb::CarConfig48 IPCPSignalManager::getcarconfig48() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig48));
        }
        if (signal.has_value()){
            return sdb::CarConfig48(signal->value.int32Values[0]);
        }
        return sdb::CarConfig48(-1);
    }

    sdb::Carconfig49 IPCPSignalManager::getcarconfig49() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig49));
        }
        if (signal.has_value()){
            return sdb::Carconfig49(signal->value.int32Values[0]);
        }
        return sdb::Carconfig49(-1);
    }

    sdb::Carconfig50 IPCPSignalManager::getcarconfig50() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig50));
        }
        if (signal.has_value()){
            return sdb::Carconfig50(signal->value.int32Values[0]);
        }
        return sdb::Carconfig50(-1);
    }

    sdb::Carconfig51 IPCPSignalManager::getcarconfig51() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig51));
        }
        if (signal.has_value()){
            return sdb::Carconfig51(signal->value.int32Values[0]);
        }
        return sdb::Carconfig51(-1);
    }

    sdb::Carconfig52 IPCPSignalManager::getcarconfig52() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig52));
        }
        if (signal.has_value()){
            return sdb::Carconfig52(signal->value.int32Values[0]);
        }
        return sdb::Carconfig52(-1);
    }

    sdb::CarConfig53 IPCPSignalManager::getcarconfig53() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig53));
        }
        if (signal.has_value()){
            return sdb::CarConfig53(signal->value.int32Values[0]);
        }
        return sdb::CarConfig53(-1);
    }

    sdb::Carconfig54 IPCPSignalManager::getcarconfig54() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig54));
        }
        if (signal.has_value()){
            return sdb::Carconfig54(signal->value.int32Values[0]);
        }
        return sdb::Carconfig54(-1);
    }

    sdb::Carconfig55 IPCPSignalManager::getcarconfig55() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig55));
        }
        if (signal.has_value()){
            return sdb::Carconfig55(signal->value.int32Values[0]);
        }
        return sdb::Carconfig55(-1);
    }

    sdb::Carconfig56 IPCPSignalManager::getcarconfig56() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig56));
        }
        if (signal.has_value()){
            return sdb::Carconfig56(signal->value.int32Values[0]);
        }
        return sdb::Carconfig56(-1);
    }

    sdb::Carconfig57 IPCPSignalManager::getcarconfig57() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig57));
        }
        if (signal.has_value()){
            return sdb::Carconfig57(signal->value.int32Values[0]);
        }
        return sdb::Carconfig57(-1);
    }

    sdb::CarConfig58 IPCPSignalManager::getcarconfig58() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig58));
        }
        if (signal.has_value()){
            return sdb::CarConfig58(signal->value.int32Values[0]);
        }
        return sdb::CarConfig58(-1);
    }

    sdb::CarConfig59 IPCPSignalManager::getcarconfig59() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig59));
        }
        if (signal.has_value()){
            return sdb::CarConfig59(signal->value.int32Values[0]);
        }
        return sdb::CarConfig59(-1);
    }

    sdb::CarConfig60 IPCPSignalManager::getcarconfig60() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig60));
        }
        if (signal.has_value()){
            return sdb::CarConfig60(signal->value.int32Values[0]);
        }
        return sdb::CarConfig60(-1);
    }

    sdb::Carconfig61 IPCPSignalManager::getcarconfig61() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig61));
        }
        if (signal.has_value()){
            return sdb::Carconfig61(signal->value.int32Values[0]);
        }
        return sdb::Carconfig61(-1);
    }

    sdb::Carconfig62 IPCPSignalManager::getcarconfig62() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig62));
        }
        if (signal.has_value()){
            return sdb::Carconfig62(signal->value.int32Values[0]);
        }
        return sdb::Carconfig62(-1);
    }

    sdb::Carconfig63 IPCPSignalManager::getcarconfig63() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig63));
        }
        if (signal.has_value()){
            return sdb::Carconfig63(signal->value.int32Values[0]);
        }
        return sdb::Carconfig63(-1);
    }

    sdb::CarConfig64 IPCPSignalManager::getcarconfig64() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig64));
        }
        if (signal.has_value()){
            return sdb::CarConfig64(signal->value.int32Values[0]);
        }
        return sdb::CarConfig64(-1);
    }

    sdb::CarConfig65 IPCPSignalManager::getcarconfig65() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig65));
        }
        if (signal.has_value()){
            return sdb::CarConfig65(signal->value.int32Values[0]);
        }
        return sdb::CarConfig65(-1);
    }

    sdb::CarConfig66 IPCPSignalManager::getcarconfig66() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig66));
        }
        if (signal.has_value()){
            return sdb::CarConfig66(signal->value.int32Values[0]);
        }
        return sdb::CarConfig66(-1);
    }

    sdb::Carconfig67 IPCPSignalManager::getcarconfig67() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig67));
        }
        if (signal.has_value()){
            return sdb::Carconfig67(signal->value.int32Values[0]);
        }
        return sdb::Carconfig67(-1);
    }

    sdb::Carconfig68 IPCPSignalManager::getcarconfig68() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig68));
        }
        if (signal.has_value()){
            return sdb::Carconfig68(signal->value.int32Values[0]);
        }
        return sdb::Carconfig68(-1);
    }

    sdb::Carconfig69 IPCPSignalManager::getcarconfig69() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig69));
        }
        if (signal.has_value()){
            return sdb::Carconfig69(signal->value.int32Values[0]);
        }
        return sdb::Carconfig69(-1);
    }

    sdb::CarConfig70 IPCPSignalManager::getcarconfig70() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig70));
        }
        if (signal.has_value()){
            return sdb::CarConfig70(signal->value.int32Values[0]);
        }
        return sdb::CarConfig70(-1);
    }

    sdb::Carconfig71 IPCPSignalManager::getcarconfig71() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig71));
        }
        if (signal.has_value()){
            return sdb::Carconfig71(signal->value.int32Values[0]);
        }
        return sdb::Carconfig71(-1);
    }

    sdb::Carconfig72 IPCPSignalManager::getcarconfig72() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig72));
        }
        if (signal.has_value()){
            return sdb::Carconfig72(signal->value.int32Values[0]);
        }
        return sdb::Carconfig72(-1);
    }

    sdb::Carconfig73 IPCPSignalManager::getcarconfig73() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig73));
        }
        if (signal.has_value()){
            return sdb::Carconfig73(signal->value.int32Values[0]);
        }
        return sdb::Carconfig73(-1);
    }

    sdb::Carconfig74 IPCPSignalManager::getcarconfig74() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig74));
        }
        if (signal.has_value()){
            return sdb::Carconfig74(signal->value.int32Values[0]);
        }
        return sdb::Carconfig74(-1);
    }

    sdb::Carconfig75 IPCPSignalManager::getcarconfig75() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig75));
        }
        if (signal.has_value()){
            return sdb::Carconfig75(signal->value.int32Values[0]);
        }
        return sdb::Carconfig75(-1);
    }

    sdb::Carconfig76 IPCPSignalManager::getcarconfig76() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig76));
        }
        if (signal.has_value()){
            return sdb::Carconfig76(signal->value.int32Values[0]);
        }
        return sdb::Carconfig76(-1);
    }

    sdb::CarConfig77 IPCPSignalManager::getcarconfig77() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig77));
        }
        if (signal.has_value()){
            return sdb::CarConfig77(signal->value.int32Values[0]);
        }
        return sdb::CarConfig77(-1);
    }

    sdb::Carconfig78 IPCPSignalManager::getcarconfig78() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig78));
        }
        if (signal.has_value()){
            return sdb::Carconfig78(signal->value.int32Values[0]);
        }
        return sdb::Carconfig78(-1);
    }

    sdb::Carconfig79 IPCPSignalManager::getcarconfig79() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig79));
        }
        if (signal.has_value()){
            return sdb::Carconfig79(signal->value.int32Values[0]);
        }
        return sdb::Carconfig79(-1);
    }

    sdb::CarConfig80 IPCPSignalManager::getcarconfig80() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig80));
        }
        if (signal.has_value()){
            return sdb::CarConfig80(signal->value.int32Values[0]);
        }
        return sdb::CarConfig80(-1);
    }

    sdb::CarConfig81 IPCPSignalManager::getcarconfig81() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig81));
        }
        if (signal.has_value()){
            return sdb::CarConfig81(signal->value.int32Values[0]);
        }
        return sdb::CarConfig81(-1);
    }

    sdb::CarConfig82 IPCPSignalManager::getcarconfig82() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig82));
        }
        if (signal.has_value()){
            return sdb::CarConfig82(signal->value.int32Values[0]);
        }
        return sdb::CarConfig82(-1);
    }

    sdb::Carconfig83 IPCPSignalManager::getcarconfig83() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig83));
        }
        if (signal.has_value()){
            return sdb::Carconfig83(signal->value.int32Values[0]);
        }
        return sdb::Carconfig83(-1);
    }

    sdb::Carconfig84 IPCPSignalManager::getcarconfig84() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig84));
        }
        if (signal.has_value()){
            return sdb::Carconfig84(signal->value.int32Values[0]);
        }
        return sdb::Carconfig84(-1);
    }

    sdb::CarConfig85 IPCPSignalManager::getcarconfig85() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig85));
        }
        if (signal.has_value()){
            return sdb::CarConfig85(signal->value.int32Values[0]);
        }
        return sdb::CarConfig85(-1);
    }

    sdb::Carconfig86 IPCPSignalManager::getcarconfig86() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig86));
        }
        if (signal.has_value()){
            return sdb::Carconfig86(signal->value.int32Values[0]);
        }
        return sdb::Carconfig86(-1);
    }

    sdb::CarConfig87 IPCPSignalManager::getcarconfig87() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig87));
        }
        if (signal.has_value()){
            return sdb::CarConfig87(signal->value.int32Values[0]);
        }
        return sdb::CarConfig87(-1);
    }

    sdb::CarConfig88 IPCPSignalManager::getcarconfig88() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig88));
        }
        if (signal.has_value()){
            return sdb::CarConfig88(signal->value.int32Values[0]);
        }
        return sdb::CarConfig88(-1);
    }

    sdb::Carconfig89 IPCPSignalManager::getcarconfig89() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig89));
        }
        if (signal.has_value()){
            return sdb::Carconfig89(signal->value.int32Values[0]);
        }
        return sdb::Carconfig89(-1);
    }

    sdb::CarConfig90 IPCPSignalManager::getcarconfig90() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig90));
        }
        if (signal.has_value()){
            return sdb::CarConfig90(signal->value.int32Values[0]);
        }
        return sdb::CarConfig90(-1);
    }

    sdb::CarConfig91 IPCPSignalManager::getcarconfig91() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig91));
        }
        if (signal.has_value()){
            return sdb::CarConfig91(signal->value.int32Values[0]);
        }
        return sdb::CarConfig91(-1);
    }

    sdb::Carconfig92 IPCPSignalManager::getcarconfig92() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig92));
        }
        if (signal.has_value()){
            return sdb::Carconfig92(signal->value.int32Values[0]);
        }
        return sdb::Carconfig92(-1);
    }

    sdb::Carconfig93 IPCPSignalManager::getcarconfig93() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig93));
        }
        if (signal.has_value()){
            return sdb::Carconfig93(signal->value.int32Values[0]);
        }
        return sdb::Carconfig93(-1);
    }

    sdb::CarConfig94 IPCPSignalManager::getcarconfig94() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig94));
        }
        if (signal.has_value()){
            return sdb::CarConfig94(signal->value.int32Values[0]);
        }
        return sdb::CarConfig94(-1);
    }

    sdb::Carconfig95 IPCPSignalManager::getcarconfig95() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig95));
        }
        if (signal.has_value()){
            return sdb::Carconfig95(signal->value.int32Values[0]);
        }
        return sdb::Carconfig95(-1);
    }

    sdb::CarConfig96 IPCPSignalManager::getcarconfig96() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig96));
        }
        if (signal.has_value()){
            return sdb::CarConfig96(signal->value.int32Values[0]);
        }
        return sdb::CarConfig96(-1);
    }

    sdb::Carconfig97 IPCPSignalManager::getcarconfig97() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig97));
        }
        if (signal.has_value()){
            return sdb::Carconfig97(signal->value.int32Values[0]);
        }
        return sdb::Carconfig97(-1);
    }

    sdb::CarConfig98 IPCPSignalManager::getcarconfig98() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig98));
        }
        if (signal.has_value()){
            return sdb::CarConfig98(signal->value.int32Values[0]);
        }
        return sdb::CarConfig98(-1);
    }

    sdb::CarConfig99 IPCPSignalManager::getcarconfig99() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig99));
        }
        if (signal.has_value()){
            return sdb::CarConfig99(signal->value.int32Values[0]);
        }
        return sdb::CarConfig99(-1);
    }

    sdb::CarConfig100 IPCPSignalManager::getcarconfig100() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig100));
        }
        if (signal.has_value()){
            return sdb::CarConfig100(signal->value.int32Values[0]);
        }
        return sdb::CarConfig100(-1);
    }

    sdb::Carconfig101 IPCPSignalManager::getcarconfig101() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig101));
        }
        if (signal.has_value()){
            return sdb::Carconfig101(signal->value.int32Values[0]);
        }
        return sdb::Carconfig101(-1);
    }

    sdb::Carconfig102 IPCPSignalManager::getcarconfig102() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig102));
        }
        if (signal.has_value()){
            return sdb::Carconfig102(signal->value.int32Values[0]);
        }
        return sdb::Carconfig102(-1);
    }

    sdb::Carconfig103 IPCPSignalManager::getcarconfig103() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig103));
        }
        if (signal.has_value()){
            return sdb::Carconfig103(signal->value.int32Values[0]);
        }
        return sdb::Carconfig103(-1);
    }

    sdb::Carconfig104 IPCPSignalManager::getcarconfig104() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig104));
        }
        if (signal.has_value()){
            return sdb::Carconfig104(signal->value.int32Values[0]);
        }
        return sdb::Carconfig104(-1);
    }

    sdb::CarConfig105 IPCPSignalManager::getcarconfig105() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig105));
        }
        if (signal.has_value()){
            return sdb::CarConfig105(signal->value.int32Values[0]);
        }
        return sdb::CarConfig105(-1);
    }

    sdb::CarConfig106 IPCPSignalManager::getcarconfig106() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig106));
        }
        if (signal.has_value()){
            return sdb::CarConfig106(signal->value.int32Values[0]);
        }
        return sdb::CarConfig106(-1);
    }

    sdb::CarConfig107 IPCPSignalManager::getcarconfig107() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig107));
        }
        if (signal.has_value()){
            return sdb::CarConfig107(signal->value.int32Values[0]);
        }
        return sdb::CarConfig107(-1);
    }

    sdb::Carconfig108 IPCPSignalManager::getcarconfig108() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig108));
        }
        if (signal.has_value()){
            return sdb::Carconfig108(signal->value.int32Values[0]);
        }
        return sdb::Carconfig108(-1);
    }

    sdb::CarConfig109 IPCPSignalManager::getcarconfig109() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig109));
        }
        if (signal.has_value()){
            return sdb::CarConfig109(signal->value.int32Values[0]);
        }
        return sdb::CarConfig109(-1);
    }

    sdb::Carconfig110 IPCPSignalManager::getcarconfig110() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig110));
        }
        if (signal.has_value()){
            return sdb::Carconfig110(signal->value.int32Values[0]);
        }
        return sdb::Carconfig110(-1);
    }

    sdb::CarConfig111 IPCPSignalManager::getcarconfig111() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig111));
        }
        if (signal.has_value()){
            return sdb::CarConfig111(signal->value.int32Values[0]);
        }
        return sdb::CarConfig111(-1);
    }

    sdb::CarConfig112 IPCPSignalManager::getcarconfig112() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig112));
        }
        if (signal.has_value()){
            return sdb::CarConfig112(signal->value.int32Values[0]);
        }
        return sdb::CarConfig112(-1);
    }

    sdb::Carconfig113 IPCPSignalManager::getcarconfig113() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig113));
        }
        if (signal.has_value()){
            return sdb::Carconfig113(signal->value.int32Values[0]);
        }
        return sdb::Carconfig113(-1);
    }

    sdb::Carconfig114 IPCPSignalManager::getcarconfig114() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig114));
        }
        if (signal.has_value()){
            return sdb::Carconfig114(signal->value.int32Values[0]);
        }
        return sdb::Carconfig114(-1);
    }

    sdb::CarConfig115 IPCPSignalManager::getcarconfig115() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig115));
        }
        if (signal.has_value()){
            return sdb::CarConfig115(signal->value.int32Values[0]);
        }
        return sdb::CarConfig115(-1);
    }

    sdb::Carconfig116 IPCPSignalManager::getcarconfig116() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig116));
        }
        if (signal.has_value()){
            return sdb::Carconfig116(signal->value.int32Values[0]);
        }
        return sdb::Carconfig116(-1);
    }

    sdb::Carconfig117 IPCPSignalManager::getcarconfig117() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig117));
        }
        if (signal.has_value()){
            return sdb::Carconfig117(signal->value.int32Values[0]);
        }
        return sdb::Carconfig117(-1);
    }

    sdb::CarConfig118 IPCPSignalManager::getcarconfig118() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig118));
        }
        if (signal.has_value()){
            return sdb::CarConfig118(signal->value.int32Values[0]);
        }
        return sdb::CarConfig118(-1);
    }

    sdb::Carconfig119 IPCPSignalManager::getcarconfig119() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig119));
        }
        if (signal.has_value()){
            return sdb::Carconfig119(signal->value.int32Values[0]);
        }
        return sdb::Carconfig119(-1);
    }

    sdb::CarConfig120 IPCPSignalManager::getcarconfig120() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig120));
        }
        if (signal.has_value()){
            return sdb::CarConfig120(signal->value.int32Values[0]);
        }
        return sdb::CarConfig120(-1);
    }

    sdb::Carconfig121 IPCPSignalManager::getcarconfig121() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig121));
        }
        if (signal.has_value()){
            return sdb::Carconfig121(signal->value.int32Values[0]);
        }
        return sdb::Carconfig121(-1);
    }

    sdb::CarConfig122 IPCPSignalManager::getcarconfig122() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig122));
        }
        if (signal.has_value()){
            return sdb::CarConfig122(signal->value.int32Values[0]);
        }
        return sdb::CarConfig122(-1);
    }

    sdb::Carconfig123 IPCPSignalManager::getcarconfig123() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig123));
        }
        if (signal.has_value()){
            return sdb::Carconfig123(signal->value.int32Values[0]);
        }
        return sdb::Carconfig123(-1);
    }

    sdb::CarConfig124 IPCPSignalManager::getcarconfig124() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig124));
        }
        if (signal.has_value()){
            return sdb::CarConfig124(signal->value.int32Values[0]);
        }
        return sdb::CarConfig124(-1);
    }

    sdb::Carconfig125 IPCPSignalManager::getcarconfig125() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig125));
        }
        if (signal.has_value()){
            return sdb::Carconfig125(signal->value.int32Values[0]);
        }
        return sdb::Carconfig125(-1);
    }

    sdb::CarConfig126 IPCPSignalManager::getcarconfig126() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig126));
        }
        if (signal.has_value()){
            return sdb::CarConfig126(signal->value.int32Values[0]);
        }
        return sdb::CarConfig126(-1);
    }

    sdb::CarConfig127 IPCPSignalManager::getcarconfig127() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig127));
        }
        if (signal.has_value()){
            return sdb::CarConfig127(signal->value.int32Values[0]);
        }
        return sdb::CarConfig127(-1);
    }

    sdb::Carconfig128 IPCPSignalManager::getcarconfig128() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig128));
        }
        if (signal.has_value()){
            return sdb::Carconfig128(signal->value.int32Values[0]);
        }
        return sdb::Carconfig128(-1);
    }

    sdb::Carconfig129 IPCPSignalManager::getcarconfig129() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig129));
        }
        if (signal.has_value()){
            return sdb::Carconfig129(signal->value.int32Values[0]);
        }
        return sdb::Carconfig129(-1);
    }

    sdb::Carconfig130 IPCPSignalManager::getcarconfig130() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig130));
        }
        if (signal.has_value()){
            return sdb::Carconfig130(signal->value.int32Values[0]);
        }
        return sdb::Carconfig130(-1);
    }

    sdb::Carconfig131 IPCPSignalManager::getcarconfig131() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig131));
        }
        if (signal.has_value()){
            return sdb::Carconfig131(signal->value.int32Values[0]);
        }
        return sdb::Carconfig131(-1);
    }

    sdb::CarConfig132 IPCPSignalManager::getcarconfig132() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig132));
        }
        if (signal.has_value()){
            return sdb::CarConfig132(signal->value.int32Values[0]);
        }
        return sdb::CarConfig132(-1);
    }

    sdb::Carconfig133 IPCPSignalManager::getcarconfig133() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig133));
        }
        if (signal.has_value()){
            return sdb::Carconfig133(signal->value.int32Values[0]);
        }
        return sdb::Carconfig133(-1);
    }

    sdb::Carconfig134 IPCPSignalManager::getcarconfig134() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig134));
        }
        if (signal.has_value()){
            return sdb::Carconfig134(signal->value.int32Values[0]);
        }
        return sdb::Carconfig134(-1);
    }

    sdb::CarConfig135 IPCPSignalManager::getcarconfig135() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig135));
        }
        if (signal.has_value()){
            return sdb::CarConfig135(signal->value.int32Values[0]);
        }
        return sdb::CarConfig135(-1);
    }

    sdb::CarConfig136 IPCPSignalManager::getcarconfig136() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig136));
        }
        if (signal.has_value()){
            return sdb::CarConfig136(signal->value.int32Values[0]);
        }
        return sdb::CarConfig136(-1);
    }

    sdb::CarConfig137 IPCPSignalManager::getcarconfig137() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig137));
        }
        if (signal.has_value()){
            return sdb::CarConfig137(signal->value.int32Values[0]);
        }
        return sdb::CarConfig137(-1);
    }

    sdb::CarConfig138 IPCPSignalManager::getcarconfig138() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig138));
        }
        if (signal.has_value()){
            return sdb::CarConfig138(signal->value.int32Values[0]);
        }
        return sdb::CarConfig138(-1);
    }

    sdb::Carconfig139 IPCPSignalManager::getcarconfig139() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig139));
        }
        if (signal.has_value()){
            return sdb::Carconfig139(signal->value.int32Values[0]);
        }
        return sdb::Carconfig139(-1);
    }

    sdb::Carconfig140 IPCPSignalManager::getcarconfig140() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig140));
        }
        if (signal.has_value()){
            return sdb::Carconfig140(signal->value.int32Values[0]);
        }
        return sdb::Carconfig140(-1);
    }

    sdb::Carconfig141 IPCPSignalManager::getcarconfig141() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig141));
        }
        if (signal.has_value()){
            return sdb::Carconfig141(signal->value.int32Values[0]);
        }
        return sdb::Carconfig141(-1);
    }

    sdb::CarConfig142 IPCPSignalManager::getcarconfig142() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig142));
        }
        if (signal.has_value()){
            return sdb::CarConfig142(signal->value.int32Values[0]);
        }
        return sdb::CarConfig142(-1);
    }

    sdb::Carconfig143 IPCPSignalManager::getcarconfig143() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig143));
        }
        if (signal.has_value()){
            return sdb::Carconfig143(signal->value.int32Values[0]);
        }
        return sdb::Carconfig143(-1);
    }

    sdb::Carconfig144 IPCPSignalManager::getcarconfig144() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig144));
        }
        if (signal.has_value()){
            return sdb::Carconfig144(signal->value.int32Values[0]);
        }
        return sdb::Carconfig144(-1);
    }

    sdb::CarConfig145 IPCPSignalManager::getcarconfig145() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig145));
        }
        if (signal.has_value()){
            return sdb::CarConfig145(signal->value.int32Values[0]);
        }
        return sdb::CarConfig145(-1);
    }

    sdb::CarConfig146 IPCPSignalManager::getcarconfig146() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig146));
        }
        if (signal.has_value()){
            return sdb::CarConfig146(signal->value.int32Values[0]);
        }
        return sdb::CarConfig146(-1);
    }

    sdb::Carconfig147 IPCPSignalManager::getcarconfig147() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig147));
        }
        if (signal.has_value()){
            return sdb::Carconfig147(signal->value.int32Values[0]);
        }
        return sdb::Carconfig147(-1);
    }

    sdb::Carconfig148 IPCPSignalManager::getcarconfig148() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig148));
        }
        if (signal.has_value()){
            return sdb::Carconfig148(signal->value.int32Values[0]);
        }
        return sdb::Carconfig148(-1);
    }

    sdb::CarConfig149 IPCPSignalManager::getcarconfig149() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig149));
        }
        if (signal.has_value()){
            return sdb::CarConfig149(signal->value.int32Values[0]);
        }
        return sdb::CarConfig149(-1);
    }

    sdb::CarConfig150 IPCPSignalManager::getcarconfig150() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig150));
        }
        if (signal.has_value()){
            return sdb::CarConfig150(signal->value.int32Values[0]);
        }
        return sdb::CarConfig150(-1);
    }

    sdb::Carconfig151 IPCPSignalManager::getcarconfig151() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig151));
        }
        if (signal.has_value()){
            return sdb::Carconfig151(signal->value.int32Values[0]);
        }
        return sdb::Carconfig151(-1);
    }

    sdb::CarConfig152 IPCPSignalManager::getcarconfig152() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig152));
        }
        if (signal.has_value()){
            return sdb::CarConfig152(signal->value.int32Values[0]);
        }
        return sdb::CarConfig152(-1);
    }

    sdb::CarConfig153 IPCPSignalManager::getcarconfig153() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig153));
        }
        if (signal.has_value()){
            return sdb::CarConfig153(signal->value.int32Values[0]);
        }
        return sdb::CarConfig153(-1);
    }

    sdb::CarConfig154 IPCPSignalManager::getcarconfig154() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig154));
        }
        if (signal.has_value()){
            return sdb::CarConfig154(signal->value.int32Values[0]);
        }
        return sdb::CarConfig154(-1);
    }

    sdb::CarConfig155 IPCPSignalManager::getcarconfig155() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig155));
        }
        if (signal.has_value()){
            return sdb::CarConfig155(signal->value.int32Values[0]);
        }
        return sdb::CarConfig155(-1);
    }

    sdb::CarConfig156 IPCPSignalManager::getcarconfig156() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig156));
        }
        if (signal.has_value()){
            return sdb::CarConfig156(signal->value.int32Values[0]);
        }
        return sdb::CarConfig156(-1);
    }

    sdb::CarConfig157 IPCPSignalManager::getcarconfig157() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig157));
        }
        if (signal.has_value()){
            return sdb::CarConfig157(signal->value.int32Values[0]);
        }
        return sdb::CarConfig157(-1);
    }

    sdb::CarConfig158 IPCPSignalManager::getcarconfig158() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig158));
        }
        if (signal.has_value()){
            return sdb::CarConfig158(signal->value.int32Values[0]);
        }
        return sdb::CarConfig158(-1);
    }

    sdb::CarConfig159 IPCPSignalManager::getcarconfig159() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig159));
        }
        if (signal.has_value()){
            return sdb::CarConfig159(signal->value.int32Values[0]);
        }
        return sdb::CarConfig159(-1);
    }

    sdb::CarConfig160 IPCPSignalManager::getcarconfig160() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig160));
        }
        if (signal.has_value()){
            return sdb::CarConfig160(signal->value.int32Values[0]);
        }
        return sdb::CarConfig160(-1);
    }

    sdb::CarConfig161 IPCPSignalManager::getcarconfig161() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig161));
        }
        if (signal.has_value()){
            return sdb::CarConfig161(signal->value.int32Values[0]);
        }
        return sdb::CarConfig161(-1);
    }

    sdb::CarConfig162 IPCPSignalManager::getcarconfig162() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig162));
        }
        if (signal.has_value()){
            return sdb::CarConfig162(signal->value.int32Values[0]);
        }
        return sdb::CarConfig162(-1);
    }

    sdb::CarConfig163 IPCPSignalManager::getcarconfig163() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig163));
        }
        if (signal.has_value()){
            return sdb::CarConfig163(signal->value.int32Values[0]);
        }
        return sdb::CarConfig163(-1);
    }

    sdb::CarConfig164 IPCPSignalManager::getcarconfig164() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig164));
        }
        if (signal.has_value()){
            return sdb::CarConfig164(signal->value.int32Values[0]);
        }
        return sdb::CarConfig164(-1);
    }

    sdb::CarConfig165 IPCPSignalManager::getcarconfig165() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig165));
        }
        if (signal.has_value()){
            return sdb::CarConfig165(signal->value.int32Values[0]);
        }
        return sdb::CarConfig165(-1);
    }

    sdb::CarConfig166 IPCPSignalManager::getcarconfig166() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig166));
        }
        if (signal.has_value()){
            return sdb::CarConfig166(signal->value.int32Values[0]);
        }
        return sdb::CarConfig166(-1);
    }

    sdb::CarConfig167 IPCPSignalManager::getcarconfig167() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig167));
        }
        if (signal.has_value()){
            return sdb::CarConfig167(signal->value.int32Values[0]);
        }
        return sdb::CarConfig167(-1);
    }

    sdb::Carconfig168 IPCPSignalManager::getcarconfig168() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig168));
        }
        if (signal.has_value()){
            return sdb::Carconfig168(signal->value.int32Values[0]);
        }
        return sdb::Carconfig168(-1);
    }

    sdb::Carconfig169 IPCPSignalManager::getcarconfig169() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig169));
        }
        if (signal.has_value()){
            return sdb::Carconfig169(signal->value.int32Values[0]);
        }
        return sdb::Carconfig169(-1);
    }

    sdb::CarConfig170 IPCPSignalManager::getcarconfig170() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig170));
        }
        if (signal.has_value()){
            return sdb::CarConfig170(signal->value.int32Values[0]);
        }
        return sdb::CarConfig170(-1);
    }

    sdb::Carconfig171 IPCPSignalManager::getcarconfig171() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig171));
        }
        if (signal.has_value()){
            return sdb::Carconfig171(signal->value.int32Values[0]);
        }
        return sdb::Carconfig171(-1);
    }

    sdb::Carconfig172 IPCPSignalManager::getcarconfig172() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig172));
        }
        if (signal.has_value()){
            return sdb::Carconfig172(signal->value.int32Values[0]);
        }
        return sdb::Carconfig172(-1);
    }

    sdb::Carconfig173 IPCPSignalManager::getcarconfig173() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig173));
        }
        if (signal.has_value()){
            return sdb::Carconfig173(signal->value.int32Values[0]);
        }
        return sdb::Carconfig173(-1);
    }

    sdb::CarConfig174 IPCPSignalManager::getcarconfig174() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig174));
        }
        if (signal.has_value()){
            return sdb::CarConfig174(signal->value.int32Values[0]);
        }
        return sdb::CarConfig174(-1);
    }

    sdb::CarConfig175 IPCPSignalManager::getcarconfig175() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig175));
        }
        if (signal.has_value()){
            return sdb::CarConfig175(signal->value.int32Values[0]);
        }
        return sdb::CarConfig175(-1);
    }

    sdb::Carconfig176 IPCPSignalManager::getcarconfig176() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig176));
        }
        if (signal.has_value()){
            return sdb::Carconfig176(signal->value.int32Values[0]);
        }
        return sdb::Carconfig176(-1);
    }

    sdb::CarConfig177 IPCPSignalManager::getcarconfig177() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig177));
        }
        if (signal.has_value()){
            return sdb::CarConfig177(signal->value.int32Values[0]);
        }
        return sdb::CarConfig177(-1);
    }

    sdb::Carconfig178 IPCPSignalManager::getcarconfig178() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig178));
        }
        if (signal.has_value()){
            return sdb::Carconfig178(signal->value.int32Values[0]);
        }
        return sdb::Carconfig178(-1);
    }

    sdb::CarConfig179 IPCPSignalManager::getcarconfig179() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig179));
        }
        if (signal.has_value()){
            return sdb::CarConfig179(signal->value.int32Values[0]);
        }
        return sdb::CarConfig179(-1);
    }

    sdb::CarConfig180 IPCPSignalManager::getcarconfig180() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig180));
        }
        if (signal.has_value()){
            return sdb::CarConfig180(signal->value.int32Values[0]);
        }
        return sdb::CarConfig180(-1);
    }

    sdb::CarConfig181 IPCPSignalManager::getcarconfig181() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig181));
        }
        if (signal.has_value()){
            return sdb::CarConfig181(signal->value.int32Values[0]);
        }
        return sdb::CarConfig181(-1);
    }

    sdb::CarConfig182 IPCPSignalManager::getcarconfig182() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig182));
        }
        if (signal.has_value()){
            return sdb::CarConfig182(signal->value.int32Values[0]);
        }
        return sdb::CarConfig182(-1);
    }

    sdb::CarConfig183 IPCPSignalManager::getcarconfig183() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig183));
        }
        if (signal.has_value()){
            return sdb::CarConfig183(signal->value.int32Values[0]);
        }
        return sdb::CarConfig183(-1);
    }

    sdb::CarConfig184 IPCPSignalManager::getcarconfig184() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig184));
        }
        if (signal.has_value()){
            return sdb::CarConfig184(signal->value.int32Values[0]);
        }
        return sdb::CarConfig184(-1);
    }

    sdb::CarConfig185 IPCPSignalManager::getcarconfig185() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig185));
        }
        if (signal.has_value()){
            return sdb::CarConfig185(signal->value.int32Values[0]);
        }
        return sdb::CarConfig185(-1);
    }

    sdb::CarConfig186 IPCPSignalManager::getcarconfig186() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig186));
        }
        if (signal.has_value()){
            return sdb::CarConfig186(signal->value.int32Values[0]);
        }
        return sdb::CarConfig186(-1);
    }

    sdb::Carconfig187 IPCPSignalManager::getcarconfig187() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig187));
        }
        if (signal.has_value()){
            return sdb::Carconfig187(signal->value.int32Values[0]);
        }
        return sdb::Carconfig187(-1);
    }

    sdb::Carconfig188 IPCPSignalManager::getcarconfig188() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig188));
        }
        if (signal.has_value()){
            return sdb::Carconfig188(signal->value.int32Values[0]);
        }
        return sdb::Carconfig188(-1);
    }

    sdb::CarConfig189 IPCPSignalManager::getcarconfig189() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig189));
        }
        if (signal.has_value()){
            return sdb::CarConfig189(signal->value.int32Values[0]);
        }
        return sdb::CarConfig189(-1);
    }

    sdb::CarConfig190 IPCPSignalManager::getcarconfig190() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig190));
        }
        if (signal.has_value()){
            return sdb::CarConfig190(signal->value.int32Values[0]);
        }
        return sdb::CarConfig190(-1);
    }

    sdb::CarConfig191 IPCPSignalManager::getcarconfig191() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig191));
        }
        if (signal.has_value()){
            return sdb::CarConfig191(signal->value.int32Values[0]);
        }
        return sdb::CarConfig191(-1);
    }

    sdb::Carconfig192 IPCPSignalManager::getcarconfig192() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig192));
        }
        if (signal.has_value()){
            return sdb::Carconfig192(signal->value.int32Values[0]);
        }
        return sdb::Carconfig192(-1);
    }

    sdb::CarConfig193 IPCPSignalManager::getcarconfig193() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig193));
        }
        if (signal.has_value()){
            return sdb::CarConfig193(signal->value.int32Values[0]);
        }
        return sdb::CarConfig193(-1);
    }

    sdb::CarConfig194 IPCPSignalManager::getcarconfig194() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig194));
        }
        if (signal.has_value()){
            return sdb::CarConfig194(signal->value.int32Values[0]);
        }
        return sdb::CarConfig194(-1);
    }

    sdb::Carconfig195 IPCPSignalManager::getcarconfig195() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig195));
        }
        if (signal.has_value()){
            return sdb::Carconfig195(signal->value.int32Values[0]);
        }
        return sdb::Carconfig195(-1);
    }

    sdb::CarConfig196 IPCPSignalManager::getcarconfig196() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig196));
        }
        if (signal.has_value()){
            return sdb::CarConfig196(signal->value.int32Values[0]);
        }
        return sdb::CarConfig196(-1);
    }

    sdb::CarConfig197 IPCPSignalManager::getcarconfig197() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig197));
        }
        if (signal.has_value()){
            return sdb::CarConfig197(signal->value.int32Values[0]);
        }
        return sdb::CarConfig197(-1);
    }

    sdb::CarConfig198 IPCPSignalManager::getcarconfig198() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig198));
        }
        if (signal.has_value()){
            return sdb::CarConfig198(signal->value.int32Values[0]);
        }
        return sdb::CarConfig198(-1);
    }

    sdb::Carconfig199 IPCPSignalManager::getcarconfig199() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig199));
        }
        if (signal.has_value()){
            return sdb::Carconfig199(signal->value.int32Values[0]);
        }
        return sdb::Carconfig199(-1);
    }

    sdb::CarConfig200 IPCPSignalManager::getcarconfig200() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig200));
        }
        if (signal.has_value()){
            return sdb::CarConfig200(signal->value.int32Values[0]);
        }
        return sdb::CarConfig200(-1);
    }

    sdb::Carconfig201 IPCPSignalManager::getcarconfig201() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig201));
        }
        if (signal.has_value()){
            return sdb::Carconfig201(signal->value.int32Values[0]);
        }
        return sdb::Carconfig201(-1);
    }

    sdb::Carconfig202 IPCPSignalManager::getcarconfig202() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig202));
        }
        if (signal.has_value()){
            return sdb::Carconfig202(signal->value.int32Values[0]);
        }
        return sdb::Carconfig202(-1);
    }

    sdb::Carconfig203 IPCPSignalManager::getcarconfig203() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig203));
        }
        if (signal.has_value()){
            return sdb::Carconfig203(signal->value.int32Values[0]);
        }
        return sdb::Carconfig203(-1);
    }

    sdb::Carconfig204 IPCPSignalManager::getcarconfig204() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig204));
        }
        if (signal.has_value()){
            return sdb::Carconfig204(signal->value.int32Values[0]);
        }
        return sdb::Carconfig204(-1);
    }

    sdb::Carconfig205 IPCPSignalManager::getcarconfig205() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig205));
        }
        if (signal.has_value()){
            return sdb::Carconfig205(signal->value.int32Values[0]);
        }
        return sdb::Carconfig205(-1);
    }

    sdb::Carconfig206 IPCPSignalManager::getcarconfig206() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig206));
        }
        if (signal.has_value()){
            return sdb::Carconfig206(signal->value.int32Values[0]);
        }
        return sdb::Carconfig206(-1);
    }

    sdb::Carconfig207 IPCPSignalManager::getcarconfig207() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig207));
        }
        if (signal.has_value()){
            return sdb::Carconfig207(signal->value.int32Values[0]);
        }
        return sdb::Carconfig207(-1);
    }

    sdb::Carconfig208 IPCPSignalManager::getcarconfig208() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig208));
        }
        if (signal.has_value()){
            return sdb::Carconfig208(signal->value.int32Values[0]);
        }
        return sdb::Carconfig208(-1);
    }

    sdb::CarConfig209 IPCPSignalManager::getcarconfig209() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig209));
        }
        if (signal.has_value()){
            return sdb::CarConfig209(signal->value.int32Values[0]);
        }
        return sdb::CarConfig209(-1);
    }

    sdb::Carconfig210 IPCPSignalManager::getcarconfig210() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig210));
        }
        if (signal.has_value()){
            return sdb::Carconfig210(signal->value.int32Values[0]);
        }
        return sdb::Carconfig210(-1);
    }

    sdb::CarConfig211 IPCPSignalManager::getcarconfig211() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig211));
        }
        if (signal.has_value()){
            return sdb::CarConfig211(signal->value.int32Values[0]);
        }
        return sdb::CarConfig211(-1);
    }

    sdb::CarConfig212 IPCPSignalManager::getcarconfig212() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig212));
        }
        if (signal.has_value()){
            return sdb::CarConfig212(signal->value.int32Values[0]);
        }
        return sdb::CarConfig212(-1);
    }

    sdb::CarConfig213 IPCPSignalManager::getcarconfig213() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig213));
        }
        if (signal.has_value()){
            return sdb::CarConfig213(signal->value.int32Values[0]);
        }
        return sdb::CarConfig213(-1);
    }

    sdb::Carconfig214 IPCPSignalManager::getcarconfig214() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig214));
        }
        if (signal.has_value()){
            return sdb::Carconfig214(signal->value.int32Values[0]);
        }
        return sdb::Carconfig214(-1);
    }

    sdb::Carconfig215 IPCPSignalManager::getcarconfig215() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig215));
        }
        if (signal.has_value()){
            return sdb::Carconfig215(signal->value.int32Values[0]);
        }
        return sdb::Carconfig215(-1);
    }

    sdb::Carconfig216 IPCPSignalManager::getcarconfig216() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig216));
        }
        if (signal.has_value()){
            return sdb::Carconfig216(signal->value.int32Values[0]);
        }
        return sdb::Carconfig216(-1);
    }

    sdb::Carconfig217 IPCPSignalManager::getcarconfig217() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig217));
        }
        if (signal.has_value()){
            return sdb::Carconfig217(signal->value.int32Values[0]);
        }
        return sdb::Carconfig217(-1);
    }

    sdb::Carconfig218 IPCPSignalManager::getcarconfig218() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig218));
        }
        if (signal.has_value()){
            return sdb::Carconfig218(signal->value.int32Values[0]);
        }
        return sdb::Carconfig218(-1);
    }

    sdb::CarConfig219 IPCPSignalManager::getcarconfig219() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig219));
        }
        if (signal.has_value()){
            return sdb::CarConfig219(signal->value.int32Values[0]);
        }
        return sdb::CarConfig219(-1);
    }

    sdb::CarConfig220 IPCPSignalManager::getcarconfig220() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig220));
        }
        if (signal.has_value()){
            return sdb::CarConfig220(signal->value.int32Values[0]);
        }
        return sdb::CarConfig220(-1);
    }

    sdb::Carconfig221 IPCPSignalManager::getcarconfig221() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig221));
        }
        if (signal.has_value()){
            return sdb::Carconfig221(signal->value.int32Values[0]);
        }
        return sdb::Carconfig221(-1);
    }

    sdb::Carconfig222 IPCPSignalManager::getcarconfig222() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig222));
        }
        if (signal.has_value()){
            return sdb::Carconfig222(signal->value.int32Values[0]);
        }
        return sdb::Carconfig222(-1);
    }

    sdb::CarConfig223 IPCPSignalManager::getcarconfig223() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig223));
        }
        if (signal.has_value()){
            return sdb::CarConfig223(signal->value.int32Values[0]);
        }
        return sdb::CarConfig223(-1);
    }

    sdb::CarConfig224 IPCPSignalManager::getcarconfig224() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig224));
        }
        if (signal.has_value()){
            return sdb::CarConfig224(signal->value.int32Values[0]);
        }
        return sdb::CarConfig224(-1);
    }

    sdb::Carconfig225 IPCPSignalManager::getcarconfig225() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig225));
        }
        if (signal.has_value()){
            return sdb::Carconfig225(signal->value.int32Values[0]);
        }
        return sdb::Carconfig225(-1);
    }

    sdb::Carconfig226 IPCPSignalManager::getcarconfig226() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig226));
        }
        if (signal.has_value()){
            return sdb::Carconfig226(signal->value.int32Values[0]);
        }
        return sdb::Carconfig226(-1);
    }

    sdb::Carconfig227 IPCPSignalManager::getcarconfig227() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig227));
        }
        if (signal.has_value()){
            return sdb::Carconfig227(signal->value.int32Values[0]);
        }
        return sdb::Carconfig227(-1);
    }

    sdb::Carconfig228 IPCPSignalManager::getcarconfig228() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig228));
        }
        if (signal.has_value()){
            return sdb::Carconfig228(signal->value.int32Values[0]);
        }
        return sdb::Carconfig228(-1);
    }

    sdb::Carconfig229 IPCPSignalManager::getcarconfig229() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig229));
        }
        if (signal.has_value()){
            return sdb::Carconfig229(signal->value.int32Values[0]);
        }
        return sdb::Carconfig229(-1);
    }

    sdb::Carconfig230 IPCPSignalManager::getcarconfig230() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig230));
        }
        if (signal.has_value()){
            return sdb::Carconfig230(signal->value.int32Values[0]);
        }
        return sdb::Carconfig230(-1);
    }

    sdb::Carconfig231 IPCPSignalManager::getcarconfig231() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig231));
        }
        if (signal.has_value()){
            return sdb::Carconfig231(signal->value.int32Values[0]);
        }
        return sdb::Carconfig231(-1);
    }

    sdb::Carconfig232 IPCPSignalManager::getcarconfig232() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig232));
        }
        if (signal.has_value()){
            return sdb::Carconfig232(signal->value.int32Values[0]);
        }
        return sdb::Carconfig232(-1);
    }

    sdb::Carconfig233 IPCPSignalManager::getcarconfig233() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig233));
        }
        if (signal.has_value()){
            return sdb::Carconfig233(signal->value.int32Values[0]);
        }
        return sdb::Carconfig233(-1);
    }

    sdb::Carconfig234 IPCPSignalManager::getcarconfig234() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig234));
        }
        if (signal.has_value()){
            return sdb::Carconfig234(signal->value.int32Values[0]);
        }
        return sdb::Carconfig234(-1);
    }

    sdb::Carconfig235 IPCPSignalManager::getcarconfig235() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig235));
        }
        if (signal.has_value()){
            return sdb::Carconfig235(signal->value.int32Values[0]);
        }
        return sdb::Carconfig235(-1);
    }

    sdb::Carconfig236 IPCPSignalManager::getcarconfig236() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig236));
        }
        if (signal.has_value()){
            return sdb::Carconfig236(signal->value.int32Values[0]);
        }
        return sdb::Carconfig236(-1);
    }

    sdb::Carconfig237 IPCPSignalManager::getcarconfig237() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig237));
        }
        if (signal.has_value()){
            return sdb::Carconfig237(signal->value.int32Values[0]);
        }
        return sdb::Carconfig237(-1);
    }

    sdb::Carconfig238 IPCPSignalManager::getcarconfig238() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig238));
        }
        if (signal.has_value()){
            return sdb::Carconfig238(signal->value.int32Values[0]);
        }
        return sdb::Carconfig238(-1);
    }

    sdb::CarConfig239 IPCPSignalManager::getcarconfig239() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig239));
        }
        if (signal.has_value()){
            return sdb::CarConfig239(signal->value.int32Values[0]);
        }
        return sdb::CarConfig239(-1);
    }

    sdb::CarConfig240 IPCPSignalManager::getcarconfig240() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig240));
        }
        if (signal.has_value()){
            return sdb::CarConfig240(signal->value.int32Values[0]);
        }
        return sdb::CarConfig240(-1);
    }

    sdb::CarConfig241 IPCPSignalManager::getcarconfig241() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig241));
        }
        if (signal.has_value()){
            return sdb::CarConfig241(signal->value.int32Values[0]);
        }
        return sdb::CarConfig241(-1);
    }

    sdb::CarConfig242 IPCPSignalManager::getcarconfig242() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig242));
        }
        if (signal.has_value()){
            return sdb::CarConfig242(signal->value.int32Values[0]);
        }
        return sdb::CarConfig242(-1);
    }

    sdb::CarConfig243 IPCPSignalManager::getcarconfig243() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig243));
        }
        if (signal.has_value()){
            return sdb::CarConfig243(signal->value.int32Values[0]);
        }
        return sdb::CarConfig243(-1);
    }

    sdb::CarConfig244 IPCPSignalManager::getcarconfig244() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig244));
        }
        if (signal.has_value()){
            return sdb::CarConfig244(signal->value.int32Values[0]);
        }
        return sdb::CarConfig244(-1);
    }

    sdb::CarConfig245 IPCPSignalManager::getcarconfig245() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig245));
        }
        if (signal.has_value()){
            return sdb::CarConfig245(signal->value.int32Values[0]);
        }
        return sdb::CarConfig245(-1);
    }

    sdb::CarConfig246 IPCPSignalManager::getcarconfig246() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig246));
        }
        if (signal.has_value()){
            return sdb::CarConfig246(signal->value.int32Values[0]);
        }
        return sdb::CarConfig246(-1);
    }

    sdb::Carconfig247 IPCPSignalManager::getcarconfig247() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig247));
        }
        if (signal.has_value()){
            return sdb::Carconfig247(signal->value.int32Values[0]);
        }
        return sdb::Carconfig247(-1);
    }

    sdb::CarConfig248 IPCPSignalManager::getcarconfig248() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig248));
        }
        if (signal.has_value()){
            return sdb::CarConfig248(signal->value.int32Values[0]);
        }
        return sdb::CarConfig248(-1);
    }

    sdb::CarConfig249 IPCPSignalManager::getcarconfig249() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig249));
        }
        if (signal.has_value()){
            return sdb::CarConfig249(signal->value.int32Values[0]);
        }
        return sdb::CarConfig249(-1);
    }

    sdb::Carconfig250 IPCPSignalManager::getcarconfig250() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig250));
        }
        if (signal.has_value()){
            return sdb::Carconfig250(signal->value.int32Values[0]);
        }
        return sdb::Carconfig250(-1);
    }

    sdb::Carconfig251 IPCPSignalManager::getcarconfig251() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig251));
        }
        if (signal.has_value()){
            return sdb::Carconfig251(signal->value.int32Values[0]);
        }
        return sdb::Carconfig251(-1);
    }

    sdb::Carconfig252 IPCPSignalManager::getcarconfig252() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig252));
        }
        if (signal.has_value()){
            return sdb::Carconfig252(signal->value.int32Values[0]);
        }
        return sdb::Carconfig252(-1);
    }

    sdb::Carconfig253 IPCPSignalManager::getcarconfig253() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig253));
        }
        if (signal.has_value()){
            return sdb::Carconfig253(signal->value.int32Values[0]);
        }
        return sdb::Carconfig253(-1);
    }

    sdb::Carconfig254 IPCPSignalManager::getcarconfig254() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig254));
        }
        if (signal.has_value()){
            return sdb::Carconfig254(signal->value.int32Values[0]);
        }
        return sdb::Carconfig254(-1);
    }

    sdb::Carconfig255 IPCPSignalManager::getcarconfig255() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig255));
        }
        if (signal.has_value()){
            return sdb::Carconfig255(signal->value.int32Values[0]);
        }
        return sdb::Carconfig255(-1);
    }

    sdb::CarConfig256 IPCPSignalManager::getcarconfig256() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig256));
        }
        if (signal.has_value()){
            return sdb::CarConfig256(signal->value.int32Values[0]);
        }
        return sdb::CarConfig256(-1);
    }

    sdb::Carconfig257 IPCPSignalManager::getcarconfig257() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig257));
        }
        if (signal.has_value()){
            return sdb::Carconfig257(signal->value.int32Values[0]);
        }
        return sdb::Carconfig257(-1);
    }

    sdb::Carconfig258 IPCPSignalManager::getcarconfig258() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig258));
        }
        if (signal.has_value()){
            return sdb::Carconfig258(signal->value.int32Values[0]);
        }
        return sdb::Carconfig258(-1);
    }

    sdb::Carconfig259 IPCPSignalManager::getcarconfig259() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig259));
        }
        if (signal.has_value()){
            return sdb::Carconfig259(signal->value.int32Values[0]);
        }
        return sdb::Carconfig259(-1);
    }

    sdb::Carconfig260 IPCPSignalManager::getcarconfig260() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig260));
        }
        if (signal.has_value()){
            return sdb::Carconfig260(signal->value.int32Values[0]);
        }
        return sdb::Carconfig260(-1);
    }

    sdb::Carconfig261 IPCPSignalManager::getcarconfig261() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig261));
        }
        if (signal.has_value()){
            return sdb::Carconfig261(signal->value.int32Values[0]);
        }
        return sdb::Carconfig261(-1);
    }

    sdb::Carconfig262 IPCPSignalManager::getcarconfig262() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig262));
        }
        if (signal.has_value()){
            return sdb::Carconfig262(signal->value.int32Values[0]);
        }
        return sdb::Carconfig262(-1);
    }

    sdb::Carconfig263 IPCPSignalManager::getcarconfig263() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig263));
        }
        if (signal.has_value()){
            return sdb::Carconfig263(signal->value.int32Values[0]);
        }
        return sdb::Carconfig263(-1);
    }

    sdb::Carconfig264 IPCPSignalManager::getcarconfig264() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig264));
        }
        if (signal.has_value()){
            return sdb::Carconfig264(signal->value.int32Values[0]);
        }
        return sdb::Carconfig264(-1);
    }

    sdb::Carconfig265 IPCPSignalManager::getcarconfig265() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig265));
        }
        if (signal.has_value()){
            return sdb::Carconfig265(signal->value.int32Values[0]);
        }
        return sdb::Carconfig265(-1);
    }

    sdb::Carconfig266 IPCPSignalManager::getcarconfig266() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig266));
        }
        if (signal.has_value()){
            return sdb::Carconfig266(signal->value.int32Values[0]);
        }
        return sdb::Carconfig266(-1);
    }

    sdb::CarConfig267 IPCPSignalManager::getcarconfig267() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig267));
        }
        if (signal.has_value()){
            return sdb::CarConfig267(signal->value.int32Values[0]);
        }
        return sdb::CarConfig267(-1);
    }

    sdb::Carconfig268 IPCPSignalManager::getcarconfig268() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig268));
        }
        if (signal.has_value()){
            return sdb::Carconfig268(signal->value.int32Values[0]);
        }
        return sdb::Carconfig268(-1);
    }

    sdb::Carconfig269 IPCPSignalManager::getcarconfig269() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig269));
        }
        if (signal.has_value()){
            return sdb::Carconfig269(signal->value.int32Values[0]);
        }
        return sdb::Carconfig269(-1);
    }

    sdb::Carconfig270 IPCPSignalManager::getcarconfig270() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig270));
        }
        if (signal.has_value()){
            return sdb::Carconfig270(signal->value.int32Values[0]);
        }
        return sdb::Carconfig270(-1);
    }

    sdb::Carconfig271 IPCPSignalManager::getcarconfig271() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig271));
        }
        if (signal.has_value()){
            return sdb::Carconfig271(signal->value.int32Values[0]);
        }
        return sdb::Carconfig271(-1);
    }

    sdb::Carconfig272 IPCPSignalManager::getcarconfig272() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig272));
        }
        if (signal.has_value()){
            return sdb::Carconfig272(signal->value.int32Values[0]);
        }
        return sdb::Carconfig272(-1);
    }

    sdb::Carconfig273 IPCPSignalManager::getcarconfig273() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig273));
        }
        if (signal.has_value()){
            return sdb::Carconfig273(signal->value.int32Values[0]);
        }
        return sdb::Carconfig273(-1);
    }

    sdb::CarConfig274 IPCPSignalManager::getcarconfig274() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig274));
        }
        if (signal.has_value()){
            return sdb::CarConfig274(signal->value.int32Values[0]);
        }
        return sdb::CarConfig274(-1);
    }

    sdb::Carconfig275 IPCPSignalManager::getcarconfig275() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig275));
        }
        if (signal.has_value()){
            return sdb::Carconfig275(signal->value.int32Values[0]);
        }
        return sdb::Carconfig275(-1);
    }

    sdb::Carconfig276 IPCPSignalManager::getcarconfig276() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig276));
        }
        if (signal.has_value()){
            return sdb::Carconfig276(signal->value.int32Values[0]);
        }
        return sdb::Carconfig276(-1);
    }

    sdb::Carconfig277 IPCPSignalManager::getcarconfig277() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig277));
        }
        if (signal.has_value()){
            return sdb::Carconfig277(signal->value.int32Values[0]);
        }
        return sdb::Carconfig277(-1);
    }

    sdb::Carconfig278 IPCPSignalManager::getcarconfig278() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig278));
        }
        if (signal.has_value()){
            return sdb::Carconfig278(signal->value.int32Values[0]);
        }
        return sdb::Carconfig278(-1);
    }

    sdb::Carconfig279 IPCPSignalManager::getcarconfig279() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig279));
        }
        if (signal.has_value()){
            return sdb::Carconfig279(signal->value.int32Values[0]);
        }
        return sdb::Carconfig279(-1);
    }

    sdb::Carconfig280 IPCPSignalManager::getcarconfig280() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig280));
        }
        if (signal.has_value()){
            return sdb::Carconfig280(signal->value.int32Values[0]);
        }
        return sdb::Carconfig280(-1);
    }

    sdb::Carconfig281 IPCPSignalManager::getcarconfig281() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig281));
        }
        if (signal.has_value()){
            return sdb::Carconfig281(signal->value.int32Values[0]);
        }
        return sdb::Carconfig281(-1);
    }

    sdb::Carconfig282 IPCPSignalManager::getcarconfig282() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig282));
        }
        if (signal.has_value()){
            return sdb::Carconfig282(signal->value.int32Values[0]);
        }
        return sdb::Carconfig282(-1);
    }

    sdb::Carconfig283 IPCPSignalManager::getcarconfig283() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig283));
        }
        if (signal.has_value()){
            return sdb::Carconfig283(signal->value.int32Values[0]);
        }
        return sdb::Carconfig283(-1);
    }

    sdb::Carconfig284 IPCPSignalManager::getcarconfig284() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig284));
        }
        if (signal.has_value()){
            return sdb::Carconfig284(signal->value.int32Values[0]);
        }
        return sdb::Carconfig284(-1);
    }

    sdb::Carconfig285 IPCPSignalManager::getcarconfig285() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig285));
        }
        if (signal.has_value()){
            return sdb::Carconfig285(signal->value.int32Values[0]);
        }
        return sdb::Carconfig285(-1);
    }

    sdb::Carconfig286 IPCPSignalManager::getcarconfig286() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig286));
        }
        if (signal.has_value()){
            return sdb::Carconfig286(signal->value.int32Values[0]);
        }
        return sdb::Carconfig286(-1);
    }

    sdb::Carconfig287 IPCPSignalManager::getcarconfig287() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig287));
        }
        if (signal.has_value()){
            return sdb::Carconfig287(signal->value.int32Values[0]);
        }
        return sdb::Carconfig287(-1);
    }

    sdb::Carconfig288 IPCPSignalManager::getcarconfig288() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig288));
        }
        if (signal.has_value()){
            return sdb::Carconfig288(signal->value.int32Values[0]);
        }
        return sdb::Carconfig288(-1);
    }

    sdb::Carconfig289 IPCPSignalManager::getcarconfig289() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig289));
        }
        if (signal.has_value()){
            return sdb::Carconfig289(signal->value.int32Values[0]);
        }
        return sdb::Carconfig289(-1);
    }

    sdb::CarConfig290 IPCPSignalManager::getcarconfig290() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig290));
        }
        if (signal.has_value()){
            return sdb::CarConfig290(signal->value.int32Values[0]);
        }
        return sdb::CarConfig290(-1);
    }

    sdb::Carconfig291 IPCPSignalManager::getcarconfig291() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig291));
        }
        if (signal.has_value()){
            return sdb::Carconfig291(signal->value.int32Values[0]);
        }
        return sdb::Carconfig291(-1);
    }

    sdb::Carconfig292 IPCPSignalManager::getcarconfig292() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig292));
        }
        if (signal.has_value()){
            return sdb::Carconfig292(signal->value.int32Values[0]);
        }
        return sdb::Carconfig292(-1);
    }

    sdb::Carconfig293 IPCPSignalManager::getcarconfig293() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig293));
        }
        if (signal.has_value()){
            return sdb::Carconfig293(signal->value.int32Values[0]);
        }
        return sdb::Carconfig293(-1);
    }

    sdb::Carconfig294 IPCPSignalManager::getcarconfig294() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig294));
        }
        if (signal.has_value()){
            return sdb::Carconfig294(signal->value.int32Values[0]);
        }
        return sdb::Carconfig294(-1);
    }

    sdb::Carconfig295 IPCPSignalManager::getcarconfig295() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig295));
        }
        if (signal.has_value()){
            return sdb::Carconfig295(signal->value.int32Values[0]);
        }
        return sdb::Carconfig295(-1);
    }

    sdb::Carconfig296 IPCPSignalManager::getcarconfig296() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig296));
        }
        if (signal.has_value()){
            return sdb::Carconfig296(signal->value.int32Values[0]);
        }
        return sdb::Carconfig296(-1);
    }

    sdb::Carconfig297 IPCPSignalManager::getcarconfig297() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig297));
        }
        if (signal.has_value()){
            return sdb::Carconfig297(signal->value.int32Values[0]);
        }
        return sdb::Carconfig297(-1);
    }

    sdb::Carconfig298 IPCPSignalManager::getcarconfig298() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig298));
        }
        if (signal.has_value()){
            return sdb::Carconfig298(signal->value.int32Values[0]);
        }
        return sdb::Carconfig298(-1);
    }

    sdb::Carconfig299 IPCPSignalManager::getcarconfig299() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig299));
        }
        if (signal.has_value()){
            return sdb::Carconfig299(signal->value.int32Values[0]);
        }
        return sdb::Carconfig299(-1);
    }

    sdb::Carconfig300 IPCPSignalManager::getcarconfig300() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig300));
        }
        if (signal.has_value()){
            return sdb::Carconfig300(signal->value.int32Values[0]);
        }
        return sdb::Carconfig300(-1);
    }

    sdb::Carconfig301 IPCPSignalManager::getcarconfig301() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig301));
        }
        if (signal.has_value()){
            return sdb::Carconfig301(signal->value.int32Values[0]);
        }
        return sdb::Carconfig301(-1);
    }

    sdb::Carconfig302 IPCPSignalManager::getcarconfig302() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig302));
        }
        if (signal.has_value()){
            return sdb::Carconfig302(signal->value.int32Values[0]);
        }
        return sdb::Carconfig302(-1);
    }

    sdb::Carconfig303 IPCPSignalManager::getcarconfig303() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig303));
        }
        if (signal.has_value()){
            return sdb::Carconfig303(signal->value.int32Values[0]);
        }
        return sdb::Carconfig303(-1);
    }

    sdb::Carconfig304 IPCPSignalManager::getcarconfig304() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig304));
        }
        if (signal.has_value()){
            return sdb::Carconfig304(signal->value.int32Values[0]);
        }
        return sdb::Carconfig304(-1);
    }

    sdb::Carconfig305 IPCPSignalManager::getcarconfig305() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig305));
        }
        if (signal.has_value()){
            return sdb::Carconfig305(signal->value.int32Values[0]);
        }
        return sdb::Carconfig305(-1);
    }

    sdb::Carconfig306 IPCPSignalManager::getcarconfig306() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig306));
        }
        if (signal.has_value()){
            return sdb::Carconfig306(signal->value.int32Values[0]);
        }
        return sdb::Carconfig306(-1);
    }

    sdb::Carconfig307 IPCPSignalManager::getcarconfig307() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig307));
        }
        if (signal.has_value()){
            return sdb::Carconfig307(signal->value.int32Values[0]);
        }
        return sdb::Carconfig307(-1);
    }

    sdb::Carconfig308 IPCPSignalManager::getcarconfig308() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig308));
        }
        if (signal.has_value()){
            return sdb::Carconfig308(signal->value.int32Values[0]);
        }
        return sdb::Carconfig308(-1);
    }

    sdb::Carconfig309 IPCPSignalManager::getcarconfig309() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig309));
        }
        if (signal.has_value()){
            return sdb::Carconfig309(signal->value.int32Values[0]);
        }
        return sdb::Carconfig309(-1);
    }

    sdb::Carconfig310 IPCPSignalManager::getcarconfig310() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig310));
        }
        if (signal.has_value()){
            return sdb::Carconfig310(signal->value.int32Values[0]);
        }
        return sdb::Carconfig310(-1);
    }

    sdb::Carconfig311 IPCPSignalManager::getcarconfig311() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig311));
        }
        if (signal.has_value()){
            return sdb::Carconfig311(signal->value.int32Values[0]);
        }
        return sdb::Carconfig311(-1);
    }

    sdb::Carconfig312 IPCPSignalManager::getcarconfig312() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig312));
        }
        if (signal.has_value()){
            return sdb::Carconfig312(signal->value.int32Values[0]);
        }
        return sdb::Carconfig312(-1);
    }

    sdb::Carconfig313 IPCPSignalManager::getcarconfig313() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig313));
        }
        if (signal.has_value()){
            return sdb::Carconfig313(signal->value.int32Values[0]);
        }
        return sdb::Carconfig313(-1);
    }

    sdb::Carconfig314 IPCPSignalManager::getcarconfig314() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig314));
        }
        if (signal.has_value()){
            return sdb::Carconfig314(signal->value.int32Values[0]);
        }
        return sdb::Carconfig314(-1);
    }

    sdb::Carconfig315 IPCPSignalManager::getcarconfig315() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig315));
        }
        if (signal.has_value()){
            return sdb::Carconfig315(signal->value.int32Values[0]);
        }
        return sdb::Carconfig315(-1);
    }

    sdb::CarConfig316 IPCPSignalManager::getcarconfig316() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig316));
        }
        if (signal.has_value()){
            return sdb::CarConfig316(signal->value.int32Values[0]);
        }
        return sdb::CarConfig316(-1);
    }

    sdb::CarConfig317 IPCPSignalManager::getcarconfig317() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig317));
        }
        if (signal.has_value()){
            return sdb::CarConfig317(signal->value.int32Values[0]);
        }
        return sdb::CarConfig317(-1);
    }

    sdb::Carconfig318 IPCPSignalManager::getcarconfig318() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig318));
        }
        if (signal.has_value()){
            return sdb::Carconfig318(signal->value.int32Values[0]);
        }
        return sdb::Carconfig318(-1);
    }

    sdb::CarConfig319 IPCPSignalManager::getcarconfig319() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig319));
        }
        if (signal.has_value()){
            return sdb::CarConfig319(signal->value.int32Values[0]);
        }
        return sdb::CarConfig319(-1);
    }

    sdb::Carconfig320 IPCPSignalManager::getcarconfig320() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig320));
        }
        if (signal.has_value()){
            return sdb::Carconfig320(signal->value.int32Values[0]);
        }
        return sdb::Carconfig320(-1);
    }

    sdb::Carconfig321 IPCPSignalManager::getcarconfig321() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig321));
        }
        if (signal.has_value()){
            return sdb::Carconfig321(signal->value.int32Values[0]);
        }
        return sdb::Carconfig321(-1);
    }

    sdb::Carconfig322 IPCPSignalManager::getcarconfig322() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig322));
        }
        if (signal.has_value()){
            return sdb::Carconfig322(signal->value.int32Values[0]);
        }
        return sdb::Carconfig322(-1);
    }

    sdb::Carconfig323 IPCPSignalManager::getcarconfig323() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig323));
        }
        if (signal.has_value()){
            return sdb::Carconfig323(signal->value.int32Values[0]);
        }
        return sdb::Carconfig323(-1);
    }

    sdb::Carconfig324 IPCPSignalManager::getcarconfig324() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig324));
        }
        if (signal.has_value()){
            return sdb::Carconfig324(signal->value.int32Values[0]);
        }
        return sdb::Carconfig324(-1);
    }

    sdb::Carconfig325 IPCPSignalManager::getcarconfig325() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig325));
        }
        if (signal.has_value()){
            return sdb::Carconfig325(signal->value.int32Values[0]);
        }
        return sdb::Carconfig325(-1);
    }

    sdb::Carconfig326 IPCPSignalManager::getcarconfig326() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig326));
        }
        if (signal.has_value()){
            return sdb::Carconfig326(signal->value.int32Values[0]);
        }
        return sdb::Carconfig326(-1);
    }

    sdb::Carconfig327 IPCPSignalManager::getcarconfig327() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig327));
        }
        if (signal.has_value()){
            return sdb::Carconfig327(signal->value.int32Values[0]);
        }
        return sdb::Carconfig327(-1);
    }

    sdb::Carconfig328 IPCPSignalManager::getcarconfig328() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig328));
        }
        if (signal.has_value()){
            return sdb::Carconfig328(signal->value.int32Values[0]);
        }
        return sdb::Carconfig328(-1);
    }

    sdb::Carconfig329 IPCPSignalManager::getcarconfig329() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig329));
        }
        if (signal.has_value()){
            return sdb::Carconfig329(signal->value.int32Values[0]);
        }
        return sdb::Carconfig329(-1);
    }

    sdb::Carconfig330 IPCPSignalManager::getcarconfig330() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig330));
        }
        if (signal.has_value()){
            return sdb::Carconfig330(signal->value.int32Values[0]);
        }
        return sdb::Carconfig330(-1);
    }

    sdb::Carconfig331 IPCPSignalManager::getcarconfig331() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig331));
        }
        if (signal.has_value()){
            return sdb::Carconfig331(signal->value.int32Values[0]);
        }
        return sdb::Carconfig331(-1);
    }

    sdb::Carconfig332 IPCPSignalManager::getcarconfig332() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig332));
        }
        if (signal.has_value()){
            return sdb::Carconfig332(signal->value.int32Values[0]);
        }
        return sdb::Carconfig332(-1);
    }

    sdb::Carconfig333 IPCPSignalManager::getcarconfig333() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig333));
        }
        if (signal.has_value()){
            return sdb::Carconfig333(signal->value.int32Values[0]);
        }
        return sdb::Carconfig333(-1);
    }

    sdb::Carconfig334 IPCPSignalManager::getcarconfig334() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig334));
        }
        if (signal.has_value()){
            return sdb::Carconfig334(signal->value.int32Values[0]);
        }
        return sdb::Carconfig334(-1);
    }

    sdb::Carconfig335 IPCPSignalManager::getcarconfig335() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig335));
        }
        if (signal.has_value()){
            return sdb::Carconfig335(signal->value.int32Values[0]);
        }
        return sdb::Carconfig335(-1);
    }

    sdb::CarConfig336 IPCPSignalManager::getcarconfig336() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig336));
        }
        if (signal.has_value()){
            return sdb::CarConfig336(signal->value.int32Values[0]);
        }
        return sdb::CarConfig336(-1);
    }

    sdb::Carconfig337 IPCPSignalManager::getcarconfig337() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig337));
        }
        if (signal.has_value()){
            return sdb::Carconfig337(signal->value.int32Values[0]);
        }
        return sdb::Carconfig337(-1);
    }

    sdb::Carconfig338 IPCPSignalManager::getcarconfig338() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig338));
        }
        if (signal.has_value()){
            return sdb::Carconfig338(signal->value.int32Values[0]);
        }
        return sdb::Carconfig338(-1);
    }

    sdb::Carconfig339 IPCPSignalManager::getcarconfig339() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig339));
        }
        if (signal.has_value()){
            return sdb::Carconfig339(signal->value.int32Values[0]);
        }
        return sdb::Carconfig339(-1);
    }

    sdb::CarConfig340 IPCPSignalManager::getcarconfig340() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig340));
        }
        if (signal.has_value()){
            return sdb::CarConfig340(signal->value.int32Values[0]);
        }
        return sdb::CarConfig340(-1);
    }

    sdb::Carconfig341 IPCPSignalManager::getcarconfig341() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig341));
        }
        if (signal.has_value()){
            return sdb::Carconfig341(signal->value.int32Values[0]);
        }
        return sdb::Carconfig341(-1);
    }

    sdb::Carconfig342 IPCPSignalManager::getcarconfig342() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig342));
        }
        if (signal.has_value()){
            return sdb::Carconfig342(signal->value.int32Values[0]);
        }
        return sdb::Carconfig342(-1);
    }

    sdb::Carconfig343 IPCPSignalManager::getcarconfig343() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig343));
        }
        if (signal.has_value()){
            return sdb::Carconfig343(signal->value.int32Values[0]);
        }
        return sdb::Carconfig343(-1);
    }

    sdb::CarConfig344 IPCPSignalManager::getcarconfig344() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig344));
        }
        if (signal.has_value()){
            return sdb::CarConfig344(signal->value.int32Values[0]);
        }
        return sdb::CarConfig344(-1);
    }

    sdb::Carconfig345 IPCPSignalManager::getcarconfig345() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig345));
        }
        if (signal.has_value()){
            return sdb::Carconfig345(signal->value.int32Values[0]);
        }
        return sdb::Carconfig345(-1);
    }

    sdb::CarConfig346 IPCPSignalManager::getcarconfig346() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig346));
        }
        if (signal.has_value()){
            return sdb::CarConfig346(signal->value.int32Values[0]);
        }
        return sdb::CarConfig346(-1);
    }

    sdb::Carconfig347 IPCPSignalManager::getcarconfig347() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig347));
        }
        if (signal.has_value()){
            return sdb::Carconfig347(signal->value.int32Values[0]);
        }
        return sdb::Carconfig347(-1);
    }

    sdb::Carconfig348 IPCPSignalManager::getcarconfig348() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig348));
        }
        if (signal.has_value()){
            return sdb::Carconfig348(signal->value.int32Values[0]);
        }
        return sdb::Carconfig348(-1);
    }

    sdb::CarConfig349 IPCPSignalManager::getcarconfig349() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig349));
        }
        if (signal.has_value()){
            return sdb::CarConfig349(signal->value.int32Values[0]);
        }
        return sdb::CarConfig349(-1);
    }

    sdb::CarConfig350 IPCPSignalManager::getcarconfig350() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig350));
        }
        if (signal.has_value()){
            return sdb::CarConfig350(signal->value.int32Values[0]);
        }
        return sdb::CarConfig350(-1);
    }

    sdb::CarConfig351 IPCPSignalManager::getcarconfig351() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig351));
        }
        if (signal.has_value()){
            return sdb::CarConfig351(signal->value.int32Values[0]);
        }
        return sdb::CarConfig351(-1);
    }

    sdb::Carconfig352 IPCPSignalManager::getcarconfig352() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig352));
        }
        if (signal.has_value()){
            return sdb::Carconfig352(signal->value.int32Values[0]);
        }
        return sdb::Carconfig352(-1);
    }

    sdb::CarConfig353 IPCPSignalManager::getcarconfig353() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig353));
        }
        if (signal.has_value()){
            return sdb::CarConfig353(signal->value.int32Values[0]);
        }
        return sdb::CarConfig353(-1);
    }

    sdb::Carconfig354 IPCPSignalManager::getcarconfig354() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig354));
        }
        if (signal.has_value()){
            return sdb::Carconfig354(signal->value.int32Values[0]);
        }
        return sdb::Carconfig354(-1);
    }

    sdb::Carconfig355 IPCPSignalManager::getcarconfig355() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig355));
        }
        if (signal.has_value()){
            return sdb::Carconfig355(signal->value.int32Values[0]);
        }
        return sdb::Carconfig355(-1);
    }

    sdb::Carconfig356 IPCPSignalManager::getcarconfig356() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig356));
        }
        if (signal.has_value()){
            return sdb::Carconfig356(signal->value.int32Values[0]);
        }
        return sdb::Carconfig356(-1);
    }

    sdb::Carconfig357 IPCPSignalManager::getcarconfig357() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig357));
        }
        if (signal.has_value()){
            return sdb::Carconfig357(signal->value.int32Values[0]);
        }
        return sdb::Carconfig357(-1);
    }

    sdb::CarConfig358 IPCPSignalManager::getcarconfig358() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig358));
        }
        if (signal.has_value()){
            return sdb::CarConfig358(signal->value.int32Values[0]);
        }
        return sdb::CarConfig358(-1);
    }

    sdb::Carconfig359 IPCPSignalManager::getcarconfig359() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig359));
        }
        if (signal.has_value()){
            return sdb::Carconfig359(signal->value.int32Values[0]);
        }
        return sdb::Carconfig359(-1);
    }

    sdb::CarConfig360 IPCPSignalManager::getcarconfig360() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig360));
        }
        if (signal.has_value()){
            return sdb::CarConfig360(signal->value.int32Values[0]);
        }
        return sdb::CarConfig360(-1);
    }

    sdb::Carconfig361 IPCPSignalManager::getcarconfig361() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig361));
        }
        if (signal.has_value()){
            return sdb::Carconfig361(signal->value.int32Values[0]);
        }
        return sdb::Carconfig361(-1);
    }

    sdb::Carconfig362 IPCPSignalManager::getcarconfig362() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig362));
        }
        if (signal.has_value()){
            return sdb::Carconfig362(signal->value.int32Values[0]);
        }
        return sdb::Carconfig362(-1);
    }

    sdb::Carconfig363 IPCPSignalManager::getcarconfig363() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig363));
        }
        if (signal.has_value()){
            return sdb::Carconfig363(signal->value.int32Values[0]);
        }
        return sdb::Carconfig363(-1);
    }

    sdb::CarConfig364 IPCPSignalManager::getcarconfig364() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig364));
        }
        if (signal.has_value()){
            return sdb::CarConfig364(signal->value.int32Values[0]);
        }
        return sdb::CarConfig364(-1);
    }

    sdb::Carconfig365 IPCPSignalManager::getcarconfig365() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig365));
        }
        if (signal.has_value()){
            return sdb::Carconfig365(signal->value.int32Values[0]);
        }
        return sdb::Carconfig365(-1);
    }

    sdb::CarConfig366 IPCPSignalManager::getcarconfig366() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig366));
        }
        if (signal.has_value()){
            return sdb::CarConfig366(signal->value.int32Values[0]);
        }
        return sdb::CarConfig366(-1);
    }

    sdb::Carconfig367 IPCPSignalManager::getcarconfig367() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig367));
        }
        if (signal.has_value()){
            return sdb::Carconfig367(signal->value.int32Values[0]);
        }
        return sdb::Carconfig367(-1);
    }

    sdb::Carconfig368 IPCPSignalManager::getcarconfig368() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig368));
        }
        if (signal.has_value()){
            return sdb::Carconfig368(signal->value.int32Values[0]);
        }
        return sdb::Carconfig368(-1);
    }

    sdb::Carconfig369 IPCPSignalManager::getcarconfig369() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig369));
        }
        if (signal.has_value()){
            return sdb::Carconfig369(signal->value.int32Values[0]);
        }
        return sdb::Carconfig369(-1);
    }

    sdb::Carconfig370 IPCPSignalManager::getcarconfig370() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig370));
        }
        if (signal.has_value()){
            return sdb::Carconfig370(signal->value.int32Values[0]);
        }
        return sdb::Carconfig370(-1);
    }

    sdb::CarConfig371 IPCPSignalManager::getcarconfig371() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig371));
        }
        if (signal.has_value()){
            return sdb::CarConfig371(signal->value.int32Values[0]);
        }
        return sdb::CarConfig371(-1);
    }

    sdb::CarConfig372 IPCPSignalManager::getcarconfig372() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig372));
        }
        if (signal.has_value()){
            return sdb::CarConfig372(signal->value.int32Values[0]);
        }
        return sdb::CarConfig372(-1);
    }

    sdb::Carconfig373 IPCPSignalManager::getcarconfig373() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig373));
        }
        if (signal.has_value()){
            return sdb::Carconfig373(signal->value.int32Values[0]);
        }
        return sdb::Carconfig373(-1);
    }

    sdb::Carconfig374 IPCPSignalManager::getcarconfig374() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig374));
        }
        if (signal.has_value()){
            return sdb::Carconfig374(signal->value.int32Values[0]);
        }
        return sdb::Carconfig374(-1);
    }

    sdb::Carconfig375 IPCPSignalManager::getcarconfig375() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig375));
        }
        if (signal.has_value()){
            return sdb::Carconfig375(signal->value.int32Values[0]);
        }
        return sdb::Carconfig375(-1);
    }

    sdb::Carconfig376 IPCPSignalManager::getcarconfig376() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig376));
        }
        if (signal.has_value()){
            return sdb::Carconfig376(signal->value.int32Values[0]);
        }
        return sdb::Carconfig376(-1);
    }

    sdb::Carconfig377 IPCPSignalManager::getcarconfig377() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig377));
        }
        if (signal.has_value()){
            return sdb::Carconfig377(signal->value.int32Values[0]);
        }
        return sdb::Carconfig377(-1);
    }

    sdb::Carconfig378 IPCPSignalManager::getcarconfig378() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig378));
        }
        if (signal.has_value()){
            return sdb::Carconfig378(signal->value.int32Values[0]);
        }
        return sdb::Carconfig378(-1);
    }

    sdb::Carconfig379 IPCPSignalManager::getcarconfig379() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig379));
        }
        if (signal.has_value()){
            return sdb::Carconfig379(signal->value.int32Values[0]);
        }
        return sdb::Carconfig379(-1);
    }

    sdb::Carconfig380 IPCPSignalManager::getcarconfig380() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig380));
        }
        if (signal.has_value()){
            return sdb::Carconfig380(signal->value.int32Values[0]);
        }
        return sdb::Carconfig380(-1);
    }

    sdb::Carconfig381 IPCPSignalManager::getcarconfig381() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig381));
        }
        if (signal.has_value()){
            return sdb::Carconfig381(signal->value.int32Values[0]);
        }
        return sdb::Carconfig381(-1);
    }

    sdb::Carconfig382 IPCPSignalManager::getcarconfig382() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig382));
        }
        if (signal.has_value()){
            return sdb::Carconfig382(signal->value.int32Values[0]);
        }
        return sdb::Carconfig382(-1);
    }

    sdb::Carconfig383 IPCPSignalManager::getcarconfig383() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig383));
        }
        if (signal.has_value()){
            return sdb::Carconfig383(signal->value.int32Values[0]);
        }
        return sdb::Carconfig383(-1);
    }

    sdb::Carconfig384 IPCPSignalManager::getcarconfig384() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig384));
        }
        if (signal.has_value()){
            return sdb::Carconfig384(signal->value.int32Values[0]);
        }
        return sdb::Carconfig384(-1);
    }

    sdb::Carconfig385 IPCPSignalManager::getcarconfig385() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig385));
        }
        if (signal.has_value()){
            return sdb::Carconfig385(signal->value.int32Values[0]);
        }
        return sdb::Carconfig385(-1);
    }

    sdb::Carconfig386 IPCPSignalManager::getcarconfig386() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig386));
        }
        if (signal.has_value()){
            return sdb::Carconfig386(signal->value.int32Values[0]);
        }
        return sdb::Carconfig386(-1);
    }

    sdb::Carconfig387 IPCPSignalManager::getcarconfig387() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig387));
        }
        if (signal.has_value()){
            return sdb::Carconfig387(signal->value.int32Values[0]);
        }
        return sdb::Carconfig387(-1);
    }

    sdb::Carconfig388 IPCPSignalManager::getcarconfig388() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig388));
        }
        if (signal.has_value()){
            return sdb::Carconfig388(signal->value.int32Values[0]);
        }
        return sdb::Carconfig388(-1);
    }

    sdb::Carconfig389 IPCPSignalManager::getcarconfig389() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig389));
        }
        if (signal.has_value()){
            return sdb::Carconfig389(signal->value.int32Values[0]);
        }
        return sdb::Carconfig389(-1);
    }

    sdb::Carconfig390 IPCPSignalManager::getcarconfig390() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig390));
        }
        if (signal.has_value()){
            return sdb::Carconfig390(signal->value.int32Values[0]);
        }
        return sdb::Carconfig390(-1);
    }

    sdb::Carconfig391 IPCPSignalManager::getcarconfig391() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig391));
        }
        if (signal.has_value()){
            return sdb::Carconfig391(signal->value.int32Values[0]);
        }
        return sdb::Carconfig391(-1);
    }

    sdb::Carconfig392 IPCPSignalManager::getcarconfig392() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig392));
        }
        if (signal.has_value()){
            return sdb::Carconfig392(signal->value.int32Values[0]);
        }
        return sdb::Carconfig392(-1);
    }

    sdb::Carconfig393 IPCPSignalManager::getcarconfig393() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig393));
        }
        if (signal.has_value()){
            return sdb::Carconfig393(signal->value.int32Values[0]);
        }
        return sdb::Carconfig393(-1);
    }

    sdb::Carconfig394 IPCPSignalManager::getcarconfig394() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig394));
        }
        if (signal.has_value()){
            return sdb::Carconfig394(signal->value.int32Values[0]);
        }
        return sdb::Carconfig394(-1);
    }

    sdb::Carconfig395 IPCPSignalManager::getcarconfig395() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig395));
        }
        if (signal.has_value()){
            return sdb::Carconfig395(signal->value.int32Values[0]);
        }
        return sdb::Carconfig395(-1);
    }

    sdb::Carconfig396 IPCPSignalManager::getcarconfig396() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig396));
        }
        if (signal.has_value()){
            return sdb::Carconfig396(signal->value.int32Values[0]);
        }
        return sdb::Carconfig396(-1);
    }

    sdb::Carconfig397 IPCPSignalManager::getcarconfig397() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig397));
        }
        if (signal.has_value()){
            return sdb::Carconfig397(signal->value.int32Values[0]);
        }
        return sdb::Carconfig397(-1);
    }

    sdb::Carconfig398 IPCPSignalManager::getcarconfig398() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig398));
        }
        if (signal.has_value()){
            return sdb::Carconfig398(signal->value.int32Values[0]);
        }
        return sdb::Carconfig398(-1);
    }

    sdb::Carconfig399 IPCPSignalManager::getcarconfig399() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig399));
        }
        if (signal.has_value()){
            return sdb::Carconfig399(signal->value.int32Values[0]);
        }
        return sdb::Carconfig399(-1);
    }

    sdb::Carconfig400 IPCPSignalManager::getcarconfig400() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig400));
        }
        if (signal.has_value()){
            return sdb::Carconfig400(signal->value.int32Values[0]);
        }
        return sdb::Carconfig400(-1);
    }

    sdb::CarConfig401 IPCPSignalManager::getcarconfig401() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig401));
        }
        if (signal.has_value()){
            return sdb::CarConfig401(signal->value.int32Values[0]);
        }
        return sdb::CarConfig401(-1);
    }

    sdb::Carconfig402 IPCPSignalManager::getcarconfig402() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig402));
        }
        if (signal.has_value()){
            return sdb::Carconfig402(signal->value.int32Values[0]);
        }
        return sdb::Carconfig402(-1);
    }

    sdb::Carconfig403 IPCPSignalManager::getcarconfig403() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig403));
        }
        if (signal.has_value()){
            return sdb::Carconfig403(signal->value.int32Values[0]);
        }
        return sdb::Carconfig403(-1);
    }

    sdb::Carconfig404 IPCPSignalManager::getcarconfig404() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig404));
        }
        if (signal.has_value()){
            return sdb::Carconfig404(signal->value.int32Values[0]);
        }
        return sdb::Carconfig404(-1);
    }

    sdb::Carconfig405 IPCPSignalManager::getcarconfig405() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig405));
        }
        if (signal.has_value()){
            return sdb::Carconfig405(signal->value.int32Values[0]);
        }
        return sdb::Carconfig405(-1);
    }

    sdb::Carconfig406 IPCPSignalManager::getcarconfig406() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig406));
        }
        if (signal.has_value()){
            return sdb::Carconfig406(signal->value.int32Values[0]);
        }
        return sdb::Carconfig406(-1);
    }

    sdb::CarConfig407 IPCPSignalManager::getcarconfig407() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig407));
        }
        if (signal.has_value()){
            return sdb::CarConfig407(signal->value.int32Values[0]);
        }
        return sdb::CarConfig407(-1);
    }

    sdb::Carconfig408 IPCPSignalManager::getcarconfig408() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig408));
        }
        if (signal.has_value()){
            return sdb::Carconfig408(signal->value.int32Values[0]);
        }
        return sdb::Carconfig408(-1);
    }

    sdb::Carconfig409 IPCPSignalManager::getcarconfig409() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig409));
        }
        if (signal.has_value()){
            return sdb::Carconfig409(signal->value.int32Values[0]);
        }
        return sdb::Carconfig409(-1);
    }

    sdb::Carconfig410 IPCPSignalManager::getcarconfig410() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig410));
        }
        if (signal.has_value()){
            return sdb::Carconfig410(signal->value.int32Values[0]);
        }
        return sdb::Carconfig410(-1);
    }

    sdb::Carconfig411 IPCPSignalManager::getcarconfig411() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig411));
        }
        if (signal.has_value()){
            return sdb::Carconfig411(signal->value.int32Values[0]);
        }
        return sdb::Carconfig411(-1);
    }

    sdb::Carconfig412 IPCPSignalManager::getcarconfig412() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig412));
        }
        if (signal.has_value()){
            return sdb::Carconfig412(signal->value.int32Values[0]);
        }
        return sdb::Carconfig412(-1);
    }

    sdb::Carconfig413 IPCPSignalManager::getcarconfig413() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig413));
        }
        if (signal.has_value()){
            return sdb::Carconfig413(signal->value.int32Values[0]);
        }
        return sdb::Carconfig413(-1);
    }

    sdb::Carconfig414 IPCPSignalManager::getcarconfig414() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig414));
        }
        if (signal.has_value()){
            return sdb::Carconfig414(signal->value.int32Values[0]);
        }
        return sdb::Carconfig414(-1);
    }

    sdb::Carconfig415 IPCPSignalManager::getcarconfig415() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig415));
        }
        if (signal.has_value()){
            return sdb::Carconfig415(signal->value.int32Values[0]);
        }
        return sdb::Carconfig415(-1);
    }

    sdb::Carconfig416 IPCPSignalManager::getcarconfig416() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig416));
        }
        if (signal.has_value()){
            return sdb::Carconfig416(signal->value.int32Values[0]);
        }
        return sdb::Carconfig416(-1);
    }

    sdb::Carconfig417 IPCPSignalManager::getcarconfig417() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig417));
        }
        if (signal.has_value()){
            return sdb::Carconfig417(signal->value.int32Values[0]);
        }
        return sdb::Carconfig417(-1);
    }

    sdb::Carconfig418 IPCPSignalManager::getcarconfig418() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig418));
        }
        if (signal.has_value()){
            return sdb::Carconfig418(signal->value.int32Values[0]);
        }
        return sdb::Carconfig418(-1);
    }

    sdb::Carconfig419 IPCPSignalManager::getcarconfig419() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig419));
        }
        if (signal.has_value()){
            return sdb::Carconfig419(signal->value.int32Values[0]);
        }
        return sdb::Carconfig419(-1);
    }

    sdb::Carconfig420 IPCPSignalManager::getcarconfig420() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig420));
        }
        if (signal.has_value()){
            return sdb::Carconfig420(signal->value.int32Values[0]);
        }
        return sdb::Carconfig420(-1);
    }

    sdb::Carconfig421 IPCPSignalManager::getcarconfig421() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig421));
        }
        if (signal.has_value()){
            return sdb::Carconfig421(signal->value.int32Values[0]);
        }
        return sdb::Carconfig421(-1);
    }

    sdb::Carconfig422 IPCPSignalManager::getcarconfig422() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig422));
        }
        if (signal.has_value()){
            return sdb::Carconfig422(signal->value.int32Values[0]);
        }
        return sdb::Carconfig422(-1);
    }

    sdb::Carconfig423 IPCPSignalManager::getcarconfig423() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig423));
        }
        if (signal.has_value()){
            return sdb::Carconfig423(signal->value.int32Values[0]);
        }
        return sdb::Carconfig423(-1);
    }

    sdb::Carconfig424 IPCPSignalManager::getcarconfig424() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig424));
        }
        if (signal.has_value()){
            return sdb::Carconfig424(signal->value.int32Values[0]);
        }
        return sdb::Carconfig424(-1);
    }

    sdb::Carconfig425 IPCPSignalManager::getcarconfig425() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig425));
        }
        if (signal.has_value()){
            return sdb::Carconfig425(signal->value.int32Values[0]);
        }
        return sdb::Carconfig425(-1);
    }

    sdb::Carconfig426 IPCPSignalManager::getcarconfig426() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig426));
        }
        if (signal.has_value()){
            return sdb::Carconfig426(signal->value.int32Values[0]);
        }
        return sdb::Carconfig426(-1);
    }

    sdb::Carconfig427 IPCPSignalManager::getcarconfig427() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig427));
        }
        if (signal.has_value()){
            return sdb::Carconfig427(signal->value.int32Values[0]);
        }
        return sdb::Carconfig427(-1);
    }

    sdb::Carconfig428 IPCPSignalManager::getcarconfig428() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig428));
        }
        if (signal.has_value()){
            return sdb::Carconfig428(signal->value.int32Values[0]);
        }
        return sdb::Carconfig428(-1);
    }

    sdb::Carconfig429 IPCPSignalManager::getcarconfig429() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig429));
        }
        if (signal.has_value()){
            return sdb::Carconfig429(signal->value.int32Values[0]);
        }
        return sdb::Carconfig429(-1);
    }

    sdb::Carconfig430 IPCPSignalManager::getcarconfig430() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig430));
        }
        if (signal.has_value()){
            return sdb::Carconfig430(signal->value.int32Values[0]);
        }
        return sdb::Carconfig430(-1);
    }

    sdb::Carconfig431 IPCPSignalManager::getcarconfig431() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig431));
        }
        if (signal.has_value()){
            return sdb::Carconfig431(signal->value.int32Values[0]);
        }
        return sdb::Carconfig431(-1);
    }

    sdb::Carconfig432 IPCPSignalManager::getcarconfig432() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig432));
        }
        if (signal.has_value()){
            return sdb::Carconfig432(signal->value.int32Values[0]);
        }
        return sdb::Carconfig432(-1);
    }

    sdb::Carconfig433 IPCPSignalManager::getcarconfig433() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig433));
        }
        if (signal.has_value()){
            return sdb::Carconfig433(signal->value.int32Values[0]);
        }
        return sdb::Carconfig433(-1);
    }

    sdb::Carconfig434 IPCPSignalManager::getcarconfig434() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig434));
        }
        if (signal.has_value()){
            return sdb::Carconfig434(signal->value.int32Values[0]);
        }
        return sdb::Carconfig434(-1);
    }

    sdb::Carconfig435 IPCPSignalManager::getcarconfig435() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig435));
        }
        if (signal.has_value()){
            return sdb::Carconfig435(signal->value.int32Values[0]);
        }
        return sdb::Carconfig435(-1);
    }

    sdb::Carconfig436 IPCPSignalManager::getcarconfig436() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig436));
        }
        if (signal.has_value()){
            return sdb::Carconfig436(signal->value.int32Values[0]);
        }
        return sdb::Carconfig436(-1);
    }

    sdb::Carconfig437 IPCPSignalManager::getcarconfig437() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig437));
        }
        if (signal.has_value()){
            return sdb::Carconfig437(signal->value.int32Values[0]);
        }
        return sdb::Carconfig437(-1);
    }

    sdb::Carconfig438 IPCPSignalManager::getcarconfig438() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig438));
        }
        if (signal.has_value()){
            return sdb::Carconfig438(signal->value.int32Values[0]);
        }
        return sdb::Carconfig438(-1);
    }

    sdb::Carconfig439 IPCPSignalManager::getcarconfig439() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig439));
        }
        if (signal.has_value()){
            return sdb::Carconfig439(signal->value.int32Values[0]);
        }
        return sdb::Carconfig439(-1);
    }

    sdb::Carconfig440 IPCPSignalManager::getcarconfig440() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig440));
        }
        if (signal.has_value()){
            return sdb::Carconfig440(signal->value.int32Values[0]);
        }
        return sdb::Carconfig440(-1);
    }

    sdb::CarConfig441 IPCPSignalManager::getcarconfig441() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig441));
        }
        if (signal.has_value()){
            return sdb::CarConfig441(signal->value.int32Values[0]);
        }
        return sdb::CarConfig441(-1);
    }

    sdb::Carconfig442 IPCPSignalManager::getcarconfig442() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig442));
        }
        if (signal.has_value()){
            return sdb::Carconfig442(signal->value.int32Values[0]);
        }
        return sdb::Carconfig442(-1);
    }

    sdb::CarConfig443 IPCPSignalManager::getcarconfig443() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig443));
        }
        if (signal.has_value()){
            return sdb::CarConfig443(signal->value.int32Values[0]);
        }
        return sdb::CarConfig443(-1);
    }

    sdb::Carconfig444 IPCPSignalManager::getcarconfig444() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig444));
        }
        if (signal.has_value()){
            return sdb::Carconfig444(signal->value.int32Values[0]);
        }
        return sdb::Carconfig444(-1);
    }

    sdb::Carconfig445 IPCPSignalManager::getcarconfig445() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig445));
        }
        if (signal.has_value()){
            return sdb::Carconfig445(signal->value.int32Values[0]);
        }
        return sdb::Carconfig445(-1);
    }

    sdb::Carconfig446 IPCPSignalManager::getcarconfig446() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig446));
        }
        if (signal.has_value()){
            return sdb::Carconfig446(signal->value.int32Values[0]);
        }
        return sdb::Carconfig446(-1);
    }

    sdb::Carconfig447 IPCPSignalManager::getcarconfig447() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig447));
        }
        if (signal.has_value()){
            return sdb::Carconfig447(signal->value.int32Values[0]);
        }
        return sdb::Carconfig447(-1);
    }

    sdb::Carconfig448 IPCPSignalManager::getcarconfig448() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig448));
        }
        if (signal.has_value()){
            return sdb::Carconfig448(signal->value.int32Values[0]);
        }
        return sdb::Carconfig448(-1);
    }

    sdb::CarConfig449 IPCPSignalManager::getcarconfig449() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig449));
        }
        if (signal.has_value()){
            return sdb::CarConfig449(signal->value.int32Values[0]);
        }
        return sdb::CarConfig449(-1);
    }

    sdb::CarConfig450 IPCPSignalManager::getcarconfig450() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig450));
        }
        if (signal.has_value()){
            return sdb::CarConfig450(signal->value.int32Values[0]);
        }
        return sdb::CarConfig450(-1);
    }

    sdb::Carconfig451 IPCPSignalManager::getcarconfig451() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig451));
        }
        if (signal.has_value()){
            return sdb::Carconfig451(signal->value.int32Values[0]);
        }
        return sdb::Carconfig451(-1);
    }

    sdb::CarConfig452 IPCPSignalManager::getcarconfig452() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig452));
        }
        if (signal.has_value()){
            return sdb::CarConfig452(signal->value.int32Values[0]);
        }
        return sdb::CarConfig452(-1);
    }

    sdb::Carconfig453 IPCPSignalManager::getcarconfig453() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig453));
        }
        if (signal.has_value()){
            return sdb::Carconfig453(signal->value.int32Values[0]);
        }
        return sdb::Carconfig453(-1);
    }

    sdb::CarConfig454 IPCPSignalManager::getcarconfig454() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig454));
        }
        if (signal.has_value()){
            return sdb::CarConfig454(signal->value.int32Values[0]);
        }
        return sdb::CarConfig454(-1);
    }

    sdb::CarConfig455 IPCPSignalManager::getcarconfig455() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig455));
        }
        if (signal.has_value()){
            return sdb::CarConfig455(signal->value.int32Values[0]);
        }
        return sdb::CarConfig455(-1);
    }

    sdb::Carconfig456 IPCPSignalManager::getcarconfig456() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig456));
        }
        if (signal.has_value()){
            return sdb::Carconfig456(signal->value.int32Values[0]);
        }
        return sdb::Carconfig456(-1);
    }

    sdb::Carconfig457 IPCPSignalManager::getcarconfig457() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig457));
        }
        if (signal.has_value()){
            return sdb::Carconfig457(signal->value.int32Values[0]);
        }
        return sdb::Carconfig457(-1);
    }

    sdb::Carconfig458 IPCPSignalManager::getcarconfig458() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig458));
        }
        if (signal.has_value()){
            return sdb::Carconfig458(signal->value.int32Values[0]);
        }
        return sdb::Carconfig458(-1);
    }

    sdb::Carconfig459 IPCPSignalManager::getcarconfig459() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig459));
        }
        if (signal.has_value()){
            return sdb::Carconfig459(signal->value.int32Values[0]);
        }
        return sdb::Carconfig459(-1);
    }

    sdb::CarConfig460 IPCPSignalManager::getcarconfig460() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig460));
        }
        if (signal.has_value()){
            return sdb::CarConfig460(signal->value.int32Values[0]);
        }
        return sdb::CarConfig460(-1);
    }

    sdb::Carconfig461 IPCPSignalManager::getcarconfig461() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig461));
        }
        if (signal.has_value()){
            return sdb::Carconfig461(signal->value.int32Values[0]);
        }
        return sdb::Carconfig461(-1);
    }

    sdb::Carconfig462 IPCPSignalManager::getcarconfig462() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig462));
        }
        if (signal.has_value()){
            return sdb::Carconfig462(signal->value.int32Values[0]);
        }
        return sdb::Carconfig462(-1);
    }

    sdb::CarConfig463 IPCPSignalManager::getcarconfig463() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig463));
        }
        if (signal.has_value()){
            return sdb::CarConfig463(signal->value.int32Values[0]);
        }
        return sdb::CarConfig463(-1);
    }

    sdb::Carconfig464 IPCPSignalManager::getcarconfig464() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig464));
        }
        if (signal.has_value()){
            return sdb::Carconfig464(signal->value.int32Values[0]);
        }
        return sdb::Carconfig464(-1);
    }

    sdb::CarConfig465 IPCPSignalManager::getcarconfig465() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig465));
        }
        if (signal.has_value()){
            return sdb::CarConfig465(signal->value.int32Values[0]);
        }
        return sdb::CarConfig465(-1);
    }

    sdb::CarConfig466 IPCPSignalManager::getcarconfig466() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig466));
        }
        if (signal.has_value()){
            return sdb::CarConfig466(signal->value.int32Values[0]);
        }
        return sdb::CarConfig466(-1);
    }

    sdb::Carconfig467 IPCPSignalManager::getcarconfig467() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig467));
        }
        if (signal.has_value()){
            return sdb::Carconfig467(signal->value.int32Values[0]);
        }
        return sdb::Carconfig467(-1);
    }

    sdb::CarConfig468 IPCPSignalManager::getcarconfig468() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig468));
        }
        if (signal.has_value()){
            return sdb::CarConfig468(signal->value.int32Values[0]);
        }
        return sdb::CarConfig468(-1);
    }

    sdb::Carconfig469 IPCPSignalManager::getcarconfig469() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig469));
        }
        if (signal.has_value()){
            return sdb::Carconfig469(signal->value.int32Values[0]);
        }
        return sdb::Carconfig469(-1);
    }

    sdb::Carconfig470 IPCPSignalManager::getcarconfig470() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig470));
        }
        if (signal.has_value()){
            return sdb::Carconfig470(signal->value.int32Values[0]);
        }
        return sdb::Carconfig470(-1);
    }

    sdb::CarConfig471 IPCPSignalManager::getcarconfig471() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig471));
        }
        if (signal.has_value()){
            return sdb::CarConfig471(signal->value.int32Values[0]);
        }
        return sdb::CarConfig471(-1);
    }

    sdb::CarConfig472 IPCPSignalManager::getcarconfig472() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig472));
        }
        if (signal.has_value()){
            return sdb::CarConfig472(signal->value.int32Values[0]);
        }
        return sdb::CarConfig472(-1);
    }

    sdb::CarConfig473 IPCPSignalManager::getcarconfig473() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig473));
        }
        if (signal.has_value()){
            return sdb::CarConfig473(signal->value.int32Values[0]);
        }
        return sdb::CarConfig473(-1);
    }

    sdb::CarConfig474 IPCPSignalManager::getcarconfig474() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig474));
        }
        if (signal.has_value()){
            return sdb::CarConfig474(signal->value.int32Values[0]);
        }
        return sdb::CarConfig474(-1);
    }

    sdb::CarConfig475 IPCPSignalManager::getcarconfig475() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig475));
        }
        if (signal.has_value()){
            return sdb::CarConfig475(signal->value.int32Values[0]);
        }
        return sdb::CarConfig475(-1);
    }

    sdb::CarConfig476 IPCPSignalManager::getcarconfig476() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig476));
        }
        if (signal.has_value()){
            return sdb::CarConfig476(signal->value.int32Values[0]);
        }
        return sdb::CarConfig476(-1);
    }

    sdb::CarConfig477 IPCPSignalManager::getcarconfig477() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig477));
        }
        if (signal.has_value()){
            return sdb::CarConfig477(signal->value.int32Values[0]);
        }
        return sdb::CarConfig477(-1);
    }

    sdb::CarConfig478 IPCPSignalManager::getcarconfig478() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig478));
        }
        if (signal.has_value()){
            return sdb::CarConfig478(signal->value.int32Values[0]);
        }
        return sdb::CarConfig478(-1);
    }

    sdb::CarConfig479 IPCPSignalManager::getcarconfig479() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig479));
        }
        if (signal.has_value()){
            return sdb::CarConfig479(signal->value.int32Values[0]);
        }
        return sdb::CarConfig479(-1);
    }

    sdb::CarConfig480 IPCPSignalManager::getcarconfig480() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig480));
        }
        if (signal.has_value()){
            return sdb::CarConfig480(signal->value.int32Values[0]);
        }
        return sdb::CarConfig480(-1);
    }

    sdb::CarConfig481 IPCPSignalManager::getcarconfig481() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig481));
        }
        if (signal.has_value()){
            return sdb::CarConfig481(signal->value.int32Values[0]);
        }
        return sdb::CarConfig481(-1);
    }

    sdb::Carconfig482 IPCPSignalManager::getcarconfig482() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig482));
        }
        if (signal.has_value()){
            return sdb::Carconfig482(signal->value.int32Values[0]);
        }
        return sdb::Carconfig482(-1);
    }

    sdb::CarConfig483 IPCPSignalManager::getcarconfig483() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig483));
        }
        if (signal.has_value()){
            return sdb::CarConfig483(signal->value.int32Values[0]);
        }
        return sdb::CarConfig483(-1);
    }

    sdb::Carconfig484 IPCPSignalManager::getcarconfig484() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig484));
        }
        if (signal.has_value()){
            return sdb::Carconfig484(signal->value.int32Values[0]);
        }
        return sdb::Carconfig484(-1);
    }

    sdb::CarConfig485 IPCPSignalManager::getcarconfig485() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig485));
        }
        if (signal.has_value()){
            return sdb::CarConfig485(signal->value.int32Values[0]);
        }
        return sdb::CarConfig485(-1);
    }

    sdb::CarConfig486 IPCPSignalManager::getcarconfig486() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig486));
        }
        if (signal.has_value()){
            return sdb::CarConfig486(signal->value.int32Values[0]);
        }
        return sdb::CarConfig486(-1);
    }

    sdb::Carconfig487 IPCPSignalManager::getcarconfig487() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig487));
        }
        if (signal.has_value()){
            return sdb::Carconfig487(signal->value.int32Values[0]);
        }
        return sdb::Carconfig487(-1);
    }

    sdb::CarConfig488 IPCPSignalManager::getcarconfig488() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig488));
        }
        if (signal.has_value()){
            return sdb::CarConfig488(signal->value.int32Values[0]);
        }
        return sdb::CarConfig488(-1);
    }

    sdb::CarConfig489 IPCPSignalManager::getcarconfig489() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig489));
        }
        if (signal.has_value()){
            return sdb::CarConfig489(signal->value.int32Values[0]);
        }
        return sdb::CarConfig489(-1);
    }

    sdb::Carconfig490 IPCPSignalManager::getcarconfig490() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig490));
        }
        if (signal.has_value()){
            return sdb::Carconfig490(signal->value.int32Values[0]);
        }
        return sdb::Carconfig490(-1);
    }

    sdb::Carconfig491 IPCPSignalManager::getcarconfig491() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig491));
        }
        if (signal.has_value()){
            return sdb::Carconfig491(signal->value.int32Values[0]);
        }
        return sdb::Carconfig491(-1);
    }

    sdb::Carconfig492 IPCPSignalManager::getcarconfig492() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig492));
        }
        if (signal.has_value()){
            return sdb::Carconfig492(signal->value.int32Values[0]);
        }
        return sdb::Carconfig492(-1);
    }

    sdb::CarConfig493 IPCPSignalManager::getcarconfig493() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig493));
        }
        if (signal.has_value()){
            return sdb::CarConfig493(signal->value.int32Values[0]);
        }
        return sdb::CarConfig493(-1);
    }

    sdb::CarConfig494 IPCPSignalManager::getcarconfig494() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig494));
        }
        if (signal.has_value()){
            return sdb::CarConfig494(signal->value.int32Values[0]);
        }
        return sdb::CarConfig494(-1);
    }

    sdb::CarConfig495 IPCPSignalManager::getcarconfig495() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig495));
        }
        if (signal.has_value()){
            return sdb::CarConfig495(signal->value.int32Values[0]);
        }
        return sdb::CarConfig495(-1);
    }

    sdb::Carconfig496 IPCPSignalManager::getcarconfig496() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig496));
        }
        if (signal.has_value()){
            return sdb::Carconfig496(signal->value.int32Values[0]);
        }
        return sdb::Carconfig496(-1);
    }

    sdb::CarConfig497 IPCPSignalManager::getcarconfig497() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig497));
        }
        if (signal.has_value()){
            return sdb::CarConfig497(signal->value.int32Values[0]);
        }
        return sdb::CarConfig497(-1);
    }

    sdb::CarConfig498 IPCPSignalManager::getcarconfig498() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig498));
        }
        if (signal.has_value()){
            return sdb::CarConfig498(signal->value.int32Values[0]);
        }
        return sdb::CarConfig498(-1);
    }

    sdb::CarConfig499 IPCPSignalManager::getcarconfig499() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig499));
        }
        if (signal.has_value()){
            return sdb::CarConfig499(signal->value.int32Values[0]);
        }
        return sdb::CarConfig499(-1);
    }

    sdb::CarConfig500 IPCPSignalManager::getcarconfig500() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig500));
        }
        if (signal.has_value()){
            return sdb::CarConfig500(signal->value.int32Values[0]);
        }
        return sdb::CarConfig500(-1);
    }

    sdb::CarConfig501 IPCPSignalManager::getcarconfig501() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig501));
        }
        if (signal.has_value()){
            return sdb::CarConfig501(signal->value.int32Values[0]);
        }
        return sdb::CarConfig501(-1);
    }

    sdb::CarConfig502 IPCPSignalManager::getcarconfig502() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig502));
        }
        if (signal.has_value()){
            return sdb::CarConfig502(signal->value.int32Values[0]);
        }
        return sdb::CarConfig502(-1);
    }

    sdb::Carconfig503 IPCPSignalManager::getcarconfig503() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig503));
        }
        if (signal.has_value()){
            return sdb::Carconfig503(signal->value.int32Values[0]);
        }
        return sdb::Carconfig503(-1);
    }

    sdb::CarConfig504 IPCPSignalManager::getcarconfig504() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig504));
        }
        if (signal.has_value()){
            return sdb::CarConfig504(signal->value.int32Values[0]);
        }
        return sdb::CarConfig504(-1);
    }

    sdb::CarConfig505 IPCPSignalManager::getcarconfig505() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig505));
        }
        if (signal.has_value()){
            return sdb::CarConfig505(signal->value.int32Values[0]);
        }
        return sdb::CarConfig505(-1);
    }

    sdb::CarConfig506 IPCPSignalManager::getcarconfig506() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig506));
        }
        if (signal.has_value()){
            return sdb::CarConfig506(signal->value.int32Values[0]);
        }
        return sdb::CarConfig506(-1);
    }

    sdb::CarConfig507 IPCPSignalManager::getcarconfig507() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig507));
        }
        if (signal.has_value()){
            return sdb::CarConfig507(signal->value.int32Values[0]);
        }
        return sdb::CarConfig507(-1);
    }

    sdb::Carconfig508 IPCPSignalManager::getcarconfig508() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig508));
        }
        if (signal.has_value()){
            return sdb::Carconfig508(signal->value.int32Values[0]);
        }
        return sdb::Carconfig508(-1);
    }

    sdb::Carconfig509 IPCPSignalManager::getcarconfig509() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig509));
        }
        if (signal.has_value()){
            return sdb::Carconfig509(signal->value.int32Values[0]);
        }
        return sdb::Carconfig509(-1);
    }

    sdb::CarConfig510 IPCPSignalManager::getcarconfig510() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig510));
        }
        if (signal.has_value()){
            return sdb::CarConfig510(signal->value.int32Values[0]);
        }
        return sdb::CarConfig510(-1);
    }

    sdb::CarConfig511 IPCPSignalManager::getcarconfig511() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig511));
        }
        if (signal.has_value()){
            return sdb::CarConfig511(signal->value.int32Values[0]);
        }
        return sdb::CarConfig511(-1);
    }

    sdb::Carconfig512 IPCPSignalManager::getcarconfig512() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig512));
        }
        if (signal.has_value()){
            return sdb::Carconfig512(signal->value.int32Values[0]);
        }
        return sdb::Carconfig512(-1);
    }

    sdb::Carconfig513 IPCPSignalManager::getcarconfig513() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig513));
        }
        if (signal.has_value()){
            return sdb::Carconfig513(signal->value.int32Values[0]);
        }
        return sdb::Carconfig513(-1);
    }

    sdb::Carconfig514 IPCPSignalManager::getcarconfig514() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig514));
        }
        if (signal.has_value()){
            return sdb::Carconfig514(signal->value.int32Values[0]);
        }
        return sdb::Carconfig514(-1);
    }

    sdb::Carconfig515 IPCPSignalManager::getcarconfig515() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig515));
        }
        if (signal.has_value()){
            return sdb::Carconfig515(signal->value.int32Values[0]);
        }
        return sdb::Carconfig515(-1);
    }

    sdb::Carconfig516 IPCPSignalManager::getcarconfig516() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig516));
        }
        if (signal.has_value()){
            return sdb::Carconfig516(signal->value.int32Values[0]);
        }
        return sdb::Carconfig516(-1);
    }

    sdb::Carconfig517 IPCPSignalManager::getcarconfig517() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig517));
        }
        if (signal.has_value()){
            return sdb::Carconfig517(signal->value.int32Values[0]);
        }
        return sdb::Carconfig517(-1);
    }

    sdb::CarConfig518 IPCPSignalManager::getcarconfig518() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig518));
        }
        if (signal.has_value()){
            return sdb::CarConfig518(signal->value.int32Values[0]);
        }
        return sdb::CarConfig518(-1);
    }

    sdb::Carconfig519 IPCPSignalManager::getcarconfig519() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig519));
        }
        if (signal.has_value()){
            return sdb::Carconfig519(signal->value.int32Values[0]);
        }
        return sdb::Carconfig519(-1);
    }

    sdb::Carconfig520 IPCPSignalManager::getcarconfig520() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig520));
        }
        if (signal.has_value()){
            return sdb::Carconfig520(signal->value.int32Values[0]);
        }
        return sdb::Carconfig520(-1);
    }

    sdb::CarConfig521 IPCPSignalManager::getcarconfig521() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig521));
        }
        if (signal.has_value()){
            return sdb::CarConfig521(signal->value.int32Values[0]);
        }
        return sdb::CarConfig521(-1);
    }

    sdb::CarConfig522 IPCPSignalManager::getcarconfig522() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig522));
        }
        if (signal.has_value()){
            return sdb::CarConfig522(signal->value.int32Values[0]);
        }
        return sdb::CarConfig522(-1);
    }

    sdb::CarConfig523 IPCPSignalManager::getcarconfig523() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig523));
        }
        if (signal.has_value()){
            return sdb::CarConfig523(signal->value.int32Values[0]);
        }
        return sdb::CarConfig523(-1);
    }

    sdb::Carconfig524 IPCPSignalManager::getcarconfig524() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig524));
        }
        if (signal.has_value()){
            return sdb::Carconfig524(signal->value.int32Values[0]);
        }
        return sdb::Carconfig524(-1);
    }

    sdb::CarConfig525 IPCPSignalManager::getcarconfig525() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig525));
        }
        if (signal.has_value()){
            return sdb::CarConfig525(signal->value.int32Values[0]);
        }
        return sdb::CarConfig525(-1);
    }

    sdb::CarConfig526 IPCPSignalManager::getcarconfig526() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig526));
        }
        if (signal.has_value()){
            return sdb::CarConfig526(signal->value.int32Values[0]);
        }
        return sdb::CarConfig526(-1);
    }

    sdb::CarConfig527 IPCPSignalManager::getcarconfig527() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig527));
        }
        if (signal.has_value()){
            return sdb::CarConfig527(signal->value.int32Values[0]);
        }
        return sdb::CarConfig527(-1);
    }

    sdb::Carconfig528 IPCPSignalManager::getcarconfig528() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig528));
        }
        if (signal.has_value()){
            return sdb::Carconfig528(signal->value.int32Values[0]);
        }
        return sdb::Carconfig528(-1);
    }

    sdb::Carconfig529 IPCPSignalManager::getcarconfig529() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig529));
        }
        if (signal.has_value()){
            return sdb::Carconfig529(signal->value.int32Values[0]);
        }
        return sdb::Carconfig529(-1);
    }

    sdb::Carconfig530 IPCPSignalManager::getcarconfig530() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig530));
        }
        if (signal.has_value()){
            return sdb::Carconfig530(signal->value.int32Values[0]);
        }
        return sdb::Carconfig530(-1);
    }

    sdb::CarConfig531 IPCPSignalManager::getcarconfig531() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig531));
        }
        if (signal.has_value()){
            return sdb::CarConfig531(signal->value.int32Values[0]);
        }
        return sdb::CarConfig531(-1);
    }

    sdb::CarConfig532 IPCPSignalManager::getcarconfig532() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig532));
        }
        if (signal.has_value()){
            return sdb::CarConfig532(signal->value.int32Values[0]);
        }
        return sdb::CarConfig532(-1);
    }

    sdb::CarConfig533 IPCPSignalManager::getcarconfig533() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig533));
        }
        if (signal.has_value()){
            return sdb::CarConfig533(signal->value.int32Values[0]);
        }
        return sdb::CarConfig533(-1);
    }

    sdb::CarConfig534 IPCPSignalManager::getcarconfig534() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig534));
        }
        if (signal.has_value()){
            return sdb::CarConfig534(signal->value.int32Values[0]);
        }
        return sdb::CarConfig534(-1);
    }

    sdb::CarConfig535 IPCPSignalManager::getcarconfig535() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig535));
        }
        if (signal.has_value()){
            return sdb::CarConfig535(signal->value.int32Values[0]);
        }
        return sdb::CarConfig535(-1);
    }

    sdb::CarConfig536 IPCPSignalManager::getcarconfig536() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig536));
        }
        if (signal.has_value()){
            return sdb::CarConfig536(signal->value.int32Values[0]);
        }
        return sdb::CarConfig536(-1);
    }

    sdb::CarConfig537 IPCPSignalManager::getcarconfig537() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig537));
        }
        if (signal.has_value()){
            return sdb::CarConfig537(signal->value.int32Values[0]);
        }
        return sdb::CarConfig537(-1);
    }

    sdb::Carconfig538 IPCPSignalManager::getcarconfig538() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig538));
        }
        if (signal.has_value()){
            return sdb::Carconfig538(signal->value.int32Values[0]);
        }
        return sdb::Carconfig538(-1);
    }

    sdb::Carconfig539 IPCPSignalManager::getcarconfig539() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig539));
        }
        if (signal.has_value()){
            return sdb::Carconfig539(signal->value.int32Values[0]);
        }
        return sdb::Carconfig539(-1);
    }

    sdb::CarConfig540 IPCPSignalManager::getcarconfig540() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig540));
        }
        if (signal.has_value()){
            return sdb::CarConfig540(signal->value.int32Values[0]);
        }
        return sdb::CarConfig540(-1);
    }

    sdb::CarConfig541 IPCPSignalManager::getcarconfig541() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig541));
        }
        if (signal.has_value()){
            return sdb::CarConfig541(signal->value.int32Values[0]);
        }
        return sdb::CarConfig541(-1);
    }

    sdb::CarConfig542 IPCPSignalManager::getcarconfig542() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig542));
        }
        if (signal.has_value()){
            return sdb::CarConfig542(signal->value.int32Values[0]);
        }
        return sdb::CarConfig542(-1);
    }

    sdb::Carconfig543 IPCPSignalManager::getcarconfig543() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig543));
        }
        if (signal.has_value()){
            return sdb::Carconfig543(signal->value.int32Values[0]);
        }
        return sdb::Carconfig543(-1);
    }

    sdb::CarConfig544 IPCPSignalManager::getcarconfig544() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig544));
        }
        if (signal.has_value()){
            return sdb::CarConfig544(signal->value.int32Values[0]);
        }
        return sdb::CarConfig544(-1);
    }

    sdb::Carconfig545 IPCPSignalManager::getcarconfig545() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig545));
        }
        if (signal.has_value()){
            return sdb::Carconfig545(signal->value.int32Values[0]);
        }
        return sdb::Carconfig545(-1);
    }

    sdb::CarConfig546 IPCPSignalManager::getcarconfig546() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig546));
        }
        if (signal.has_value()){
            return sdb::CarConfig546(signal->value.int32Values[0]);
        }
        return sdb::CarConfig546(-1);
    }

    sdb::Carconfig547 IPCPSignalManager::getcarconfig547() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig547));
        }
        if (signal.has_value()){
            return sdb::Carconfig547(signal->value.int32Values[0]);
        }
        return sdb::Carconfig547(-1);
    }

    sdb::CarConfig548 IPCPSignalManager::getcarconfig548() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig548));
        }
        if (signal.has_value()){
            return sdb::CarConfig548(signal->value.int32Values[0]);
        }
        return sdb::CarConfig548(-1);
    }

    sdb::Carconfig549 IPCPSignalManager::getcarconfig549() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig549));
        }
        if (signal.has_value()){
            return sdb::Carconfig549(signal->value.int32Values[0]);
        }
        return sdb::Carconfig549(-1);
    }

    sdb::Carconfig550 IPCPSignalManager::getcarconfig550() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig550));
        }
        if (signal.has_value()){
            return sdb::Carconfig550(signal->value.int32Values[0]);
        }
        return sdb::Carconfig550(-1);
    }

    sdb::CarConfig551 IPCPSignalManager::getcarconfig551() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig551));
        }
        if (signal.has_value()){
            return sdb::CarConfig551(signal->value.int32Values[0]);
        }
        return sdb::CarConfig551(-1);
    }

    sdb::CarConfig552 IPCPSignalManager::getcarconfig552() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig552));
        }
        if (signal.has_value()){
            return sdb::CarConfig552(signal->value.int32Values[0]);
        }
        return sdb::CarConfig552(-1);
    }

    sdb::CarConfig553 IPCPSignalManager::getcarconfig553() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig553));
        }
        if (signal.has_value()){
            return sdb::CarConfig553(signal->value.int32Values[0]);
        }
        return sdb::CarConfig553(-1);
    }

    sdb::Carconfig554 IPCPSignalManager::getcarconfig554() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig554));
        }
        if (signal.has_value()){
            return sdb::Carconfig554(signal->value.int32Values[0]);
        }
        return sdb::Carconfig554(-1);
    }

    sdb::Carconfig555 IPCPSignalManager::getcarconfig555() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig555));
        }
        if (signal.has_value()){
            return sdb::Carconfig555(signal->value.int32Values[0]);
        }
        return sdb::Carconfig555(-1);
    }

    sdb::Carconfig556 IPCPSignalManager::getcarconfig556() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig556));
        }
        if (signal.has_value()){
            return sdb::Carconfig556(signal->value.int32Values[0]);
        }
        return sdb::Carconfig556(-1);
    }

    sdb::Carconfig557 IPCPSignalManager::getcarconfig557() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig557));
        }
        if (signal.has_value()){
            return sdb::Carconfig557(signal->value.int32Values[0]);
        }
        return sdb::Carconfig557(-1);
    }

    sdb::Carconfig558 IPCPSignalManager::getcarconfig558() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig558));
        }
        if (signal.has_value()){
            return sdb::Carconfig558(signal->value.int32Values[0]);
        }
        return sdb::Carconfig558(-1);
    }

    sdb::Carconfig559 IPCPSignalManager::getcarconfig559() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig559));
        }
        if (signal.has_value()){
            return sdb::Carconfig559(signal->value.int32Values[0]);
        }
        return sdb::Carconfig559(-1);
    }

    sdb::Carconfig560 IPCPSignalManager::getcarconfig560() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig560));
        }
        if (signal.has_value()){
            return sdb::Carconfig560(signal->value.int32Values[0]);
        }
        return sdb::Carconfig560(-1);
    }

    sdb::Carconfig561 IPCPSignalManager::getcarconfig561() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig561));
        }
        if (signal.has_value()){
            return sdb::Carconfig561(signal->value.int32Values[0]);
        }
        return sdb::Carconfig561(-1);
    }

    sdb::Carconfig562 IPCPSignalManager::getcarconfig562() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig562));
        }
        if (signal.has_value()){
            return sdb::Carconfig562(signal->value.int32Values[0]);
        }
        return sdb::Carconfig562(-1);
    }

    sdb::CarConfig563 IPCPSignalManager::getcarconfig563() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig563));
        }
        if (signal.has_value()){
            return sdb::CarConfig563(signal->value.int32Values[0]);
        }
        return sdb::CarConfig563(-1);
    }

    sdb::CarConfig564 IPCPSignalManager::getcarconfig564() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig564));
        }
        if (signal.has_value()){
            return sdb::CarConfig564(signal->value.int32Values[0]);
        }
        return sdb::CarConfig564(-1);
    }

    sdb::CarConfig565 IPCPSignalManager::getcarconfig565() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig565));
        }
        if (signal.has_value()){
            return sdb::CarConfig565(signal->value.int32Values[0]);
        }
        return sdb::CarConfig565(-1);
    }

    sdb::CarConfig566 IPCPSignalManager::getcarconfig566() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig566));
        }
        if (signal.has_value()){
            return sdb::CarConfig566(signal->value.int32Values[0]);
        }
        return sdb::CarConfig566(-1);
    }

    sdb::CarConfig567 IPCPSignalManager::getcarconfig567() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig567));
        }
        if (signal.has_value()){
            return sdb::CarConfig567(signal->value.int32Values[0]);
        }
        return sdb::CarConfig567(-1);
    }

    sdb::CarConfig568 IPCPSignalManager::getcarconfig568() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig568));
        }
        if (signal.has_value()){
            return sdb::CarConfig568(signal->value.int32Values[0]);
        }
        return sdb::CarConfig568(-1);
    }

    sdb::CarConfig569 IPCPSignalManager::getcarconfig569() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig569));
        }
        if (signal.has_value()){
            return sdb::CarConfig569(signal->value.int32Values[0]);
        }
        return sdb::CarConfig569(-1);
    }

    sdb::Carconfig570 IPCPSignalManager::getcarconfig570() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig570));
        }
        if (signal.has_value()){
            return sdb::Carconfig570(signal->value.int32Values[0]);
        }
        return sdb::Carconfig570(-1);
    }

    sdb::Carconfig571 IPCPSignalManager::getcarconfig571() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig571));
        }
        if (signal.has_value()){
            return sdb::Carconfig571(signal->value.int32Values[0]);
        }
        return sdb::Carconfig571(-1);
    }

    sdb::CarConfig572 IPCPSignalManager::getcarconfig572() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig572));
        }
        if (signal.has_value()){
            return sdb::CarConfig572(signal->value.int32Values[0]);
        }
        return sdb::CarConfig572(-1);
    }

    sdb::CarConfig573 IPCPSignalManager::getcarconfig573() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig573));
        }
        if (signal.has_value()){
            return sdb::CarConfig573(signal->value.int32Values[0]);
        }
        return sdb::CarConfig573(-1);
    }

    sdb::CarConfig574 IPCPSignalManager::getcarconfig574() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig574));
        }
        if (signal.has_value()){
            return sdb::CarConfig574(signal->value.int32Values[0]);
        }
        return sdb::CarConfig574(-1);
    }

    sdb::CarConfig575 IPCPSignalManager::getcarconfig575() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig575));
        }
        if (signal.has_value()){
            return sdb::CarConfig575(signal->value.int32Values[0]);
        }
        return sdb::CarConfig575(-1);
    }

    sdb::Carconfig576 IPCPSignalManager::getcarconfig576() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig576));
        }
        if (signal.has_value()){
            return sdb::Carconfig576(signal->value.int32Values[0]);
        }
        return sdb::Carconfig576(-1);
    }

    sdb::Carconfig577 IPCPSignalManager::getcarconfig577() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig577));
        }
        if (signal.has_value()){
            return sdb::Carconfig577(signal->value.int32Values[0]);
        }
        return sdb::Carconfig577(-1);
    }

    sdb::CarConfig578 IPCPSignalManager::getcarconfig578() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig578));
        }
        if (signal.has_value()){
            return sdb::CarConfig578(signal->value.int32Values[0]);
        }
        return sdb::CarConfig578(-1);
    }

    sdb::Carconfig579 IPCPSignalManager::getcarconfig579() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig579));
        }
        if (signal.has_value()){
            return sdb::Carconfig579(signal->value.int32Values[0]);
        }
        return sdb::Carconfig579(-1);
    }

    sdb::CarConfig580 IPCPSignalManager::getcarconfig580() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig580));
        }
        if (signal.has_value()){
            return sdb::CarConfig580(signal->value.int32Values[0]);
        }
        return sdb::CarConfig580(-1);
    }

    sdb::CarConfig581 IPCPSignalManager::getcarconfig581() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig581));
        }
        if (signal.has_value()){
            return sdb::CarConfig581(signal->value.int32Values[0]);
        }
        return sdb::CarConfig581(-1);
    }

    sdb::CarConfig582 IPCPSignalManager::getcarconfig582() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig582));
        }
        if (signal.has_value()){
            return sdb::CarConfig582(signal->value.int32Values[0]);
        }
        return sdb::CarConfig582(-1);
    }

    sdb::Carconfig583 IPCPSignalManager::getcarconfig583() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig583));
        }
        if (signal.has_value()){
            return sdb::Carconfig583(signal->value.int32Values[0]);
        }
        return sdb::Carconfig583(-1);
    }

    sdb::CarConfig584 IPCPSignalManager::getcarconfig584() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig584));
        }
        if (signal.has_value()){
            return sdb::CarConfig584(signal->value.int32Values[0]);
        }
        return sdb::CarConfig584(-1);
    }

    sdb::CarConfig585 IPCPSignalManager::getcarconfig585() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig585));
        }
        if (signal.has_value()){
            return sdb::CarConfig585(signal->value.int32Values[0]);
        }
        return sdb::CarConfig585(-1);
    }

    sdb::CarConfig586 IPCPSignalManager::getcarconfig586() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig586));
        }
        if (signal.has_value()){
            return sdb::CarConfig586(signal->value.int32Values[0]);
        }
        return sdb::CarConfig586(-1);
    }

    sdb::Carconfig587 IPCPSignalManager::getcarconfig587() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig587));
        }
        if (signal.has_value()){
            return sdb::Carconfig587(signal->value.int32Values[0]);
        }
        return sdb::Carconfig587(-1);
    }

    sdb::Carconfig588 IPCPSignalManager::getcarconfig588() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig588));
        }
        if (signal.has_value()){
            return sdb::Carconfig588(signal->value.int32Values[0]);
        }
        return sdb::Carconfig588(-1);
    }

    sdb::CarConfig589 IPCPSignalManager::getcarconfig589() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig589));
        }
        if (signal.has_value()){
            return sdb::CarConfig589(signal->value.int32Values[0]);
        }
        return sdb::CarConfig589(-1);
    }

    sdb::CarConfig590 IPCPSignalManager::getcarconfig590() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig590));
        }
        if (signal.has_value()){
            return sdb::CarConfig590(signal->value.int32Values[0]);
        }
        return sdb::CarConfig590(-1);
    }

    sdb::CarConfig591 IPCPSignalManager::getcarconfig591() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig591));
        }
        if (signal.has_value()){
            return sdb::CarConfig591(signal->value.int32Values[0]);
        }
        return sdb::CarConfig591(-1);
    }

    sdb::Carconfig592 IPCPSignalManager::getcarconfig592() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig592));
        }
        if (signal.has_value()){
            return sdb::Carconfig592(signal->value.int32Values[0]);
        }
        return sdb::Carconfig592(-1);
    }

    sdb::Carconfig593 IPCPSignalManager::getcarconfig593() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig593));
        }
        if (signal.has_value()){
            return sdb::Carconfig593(signal->value.int32Values[0]);
        }
        return sdb::Carconfig593(-1);
    }

    sdb::CarConfig594 IPCPSignalManager::getcarconfig594() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig594));
        }
        if (signal.has_value()){
            return sdb::CarConfig594(signal->value.int32Values[0]);
        }
        return sdb::CarConfig594(-1);
    }

    sdb::CarConfig595 IPCPSignalManager::getcarconfig595() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig595));
        }
        if (signal.has_value()){
            return sdb::CarConfig595(signal->value.int32Values[0]);
        }
        return sdb::CarConfig595(-1);
    }

    sdb::CarConfig596 IPCPSignalManager::getcarconfig596() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig596));
        }
        if (signal.has_value()){
            return sdb::CarConfig596(signal->value.int32Values[0]);
        }
        return sdb::CarConfig596(-1);
    }

    sdb::CarConfig597 IPCPSignalManager::getcarconfig597() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig597));
        }
        if (signal.has_value()){
            return sdb::CarConfig597(signal->value.int32Values[0]);
        }
        return sdb::CarConfig597(-1);
    }

    sdb::CarConfig598 IPCPSignalManager::getcarconfig598() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig598));
        }
        if (signal.has_value()){
            return sdb::CarConfig598(signal->value.int32Values[0]);
        }
        return sdb::CarConfig598(-1);
    }

    sdb::CarConfig599 IPCPSignalManager::getcarconfig599() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig599));
        }
        if (signal.has_value()){
            return sdb::CarConfig599(signal->value.int32Values[0]);
        }
        return sdb::CarConfig599(-1);
    }

    sdb::CarConfig600 IPCPSignalManager::getcarconfig600() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig600));
        }
        if (signal.has_value()){
            return sdb::CarConfig600(signal->value.int32Values[0]);
        }
        return sdb::CarConfig600(-1);
    }

    sdb::CarConfig601 IPCPSignalManager::getcarconfig601() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig601));
        }
        if (signal.has_value()){
            return sdb::CarConfig601(signal->value.int32Values[0]);
        }
        return sdb::CarConfig601(-1);
    }

    sdb::CarConfig602 IPCPSignalManager::getcarconfig602() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig602));
        }
        if (signal.has_value()){
            return sdb::CarConfig602(signal->value.int32Values[0]);
        }
        return sdb::CarConfig602(-1);
    }

    sdb::CarConfig603 IPCPSignalManager::getcarconfig603() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig603));
        }
        if (signal.has_value()){
            return sdb::CarConfig603(signal->value.int32Values[0]);
        }
        return sdb::CarConfig603(-1);
    }

    sdb::CarConfig604 IPCPSignalManager::getcarconfig604() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig604));
        }
        if (signal.has_value()){
            return sdb::CarConfig604(signal->value.int32Values[0]);
        }
        return sdb::CarConfig604(-1);
    }

    sdb::CarConfig605 IPCPSignalManager::getcarconfig605() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig605));
        }
        if (signal.has_value()){
            return sdb::CarConfig605(signal->value.int32Values[0]);
        }
        return sdb::CarConfig605(-1);
    }

    sdb::CarConfig606 IPCPSignalManager::getcarconfig606() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig606));
        }
        if (signal.has_value()){
            return sdb::CarConfig606(signal->value.int32Values[0]);
        }
        return sdb::CarConfig606(-1);
    }

    sdb::CarConfig607 IPCPSignalManager::getcarconfig607() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig607));
        }
        if (signal.has_value()){
            return sdb::CarConfig607(signal->value.int32Values[0]);
        }
        return sdb::CarConfig607(-1);
    }

    sdb::CarConfig608 IPCPSignalManager::getcarconfig608() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig608));
        }
        if (signal.has_value()){
            return sdb::CarConfig608(signal->value.int32Values[0]);
        }
        return sdb::CarConfig608(-1);
    }

    sdb::CarConfig609 IPCPSignalManager::getcarconfig609() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig609));
        }
        if (signal.has_value()){
            return sdb::CarConfig609(signal->value.int32Values[0]);
        }
        return sdb::CarConfig609(-1);
    }

    sdb::CarConfig610 IPCPSignalManager::getcarconfig610() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig610));
        }
        if (signal.has_value()){
            return sdb::CarConfig610(signal->value.int32Values[0]);
        }
        return sdb::CarConfig610(-1);
    }

    sdb::CarConfig611 IPCPSignalManager::getcarconfig611() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig611));
        }
        if (signal.has_value()){
            return sdb::CarConfig611(signal->value.int32Values[0]);
        }
        return sdb::CarConfig611(-1);
    }

    sdb::CarConfig612 IPCPSignalManager::getcarconfig612() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig612));
        }
        if (signal.has_value()){
            return sdb::CarConfig612(signal->value.int32Values[0]);
        }
        return sdb::CarConfig612(-1);
    }

    sdb::CarConfig613 IPCPSignalManager::getcarconfig613() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig613));
        }
        if (signal.has_value()){
            return sdb::CarConfig613(signal->value.int32Values[0]);
        }
        return sdb::CarConfig613(-1);
    }

    sdb::CarConfig614 IPCPSignalManager::getcarconfig614() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig614));
        }
        if (signal.has_value()){
            return sdb::CarConfig614(signal->value.int32Values[0]);
        }
        return sdb::CarConfig614(-1);
    }

    sdb::CarConfig615 IPCPSignalManager::getcarconfig615() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig615));
        }
        if (signal.has_value()){
            return sdb::CarConfig615(signal->value.int32Values[0]);
        }
        return sdb::CarConfig615(-1);
    }

    sdb::CarConfig616 IPCPSignalManager::getcarconfig616() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig616));
        }
        if (signal.has_value()){
            return sdb::CarConfig616(signal->value.int32Values[0]);
        }
        return sdb::CarConfig616(-1);
    }

    sdb::CarConfig617 IPCPSignalManager::getcarconfig617() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig617));
        }
        if (signal.has_value()){
            return sdb::CarConfig617(signal->value.int32Values[0]);
        }
        return sdb::CarConfig617(-1);
    }

    sdb::CarConfig618 IPCPSignalManager::getcarconfig618() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig618));
        }
        if (signal.has_value()){
            return sdb::CarConfig618(signal->value.int32Values[0]);
        }
        return sdb::CarConfig618(-1);
    }

    sdb::CarConfig619 IPCPSignalManager::getcarconfig619() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig619));
        }
        if (signal.has_value()){
            return sdb::CarConfig619(signal->value.int32Values[0]);
        }
        return sdb::CarConfig619(-1);
    }

    sdb::CarConfig620 IPCPSignalManager::getcarconfig620() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig620));
        }
        if (signal.has_value()){
            return sdb::CarConfig620(signal->value.int32Values[0]);
        }
        return sdb::CarConfig620(-1);
    }

    sdb::CarConfig621 IPCPSignalManager::getcarconfig621() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig621));
        }
        if (signal.has_value()){
            return sdb::CarConfig621(signal->value.int32Values[0]);
        }
        return sdb::CarConfig621(-1);
    }

    sdb::CarConfig622 IPCPSignalManager::getcarconfig622() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig622));
        }
        if (signal.has_value()){
            return sdb::CarConfig622(signal->value.int32Values[0]);
        }
        return sdb::CarConfig622(-1);
    }

    sdb::CarConfig623 IPCPSignalManager::getcarconfig623() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig623));
        }
        if (signal.has_value()){
            return sdb::CarConfig623(signal->value.int32Values[0]);
        }
        return sdb::CarConfig623(-1);
    }

    sdb::CarConfig624 IPCPSignalManager::getcarconfig624() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig624));
        }
        if (signal.has_value()){
            return sdb::CarConfig624(signal->value.int32Values[0]);
        }
        return sdb::CarConfig624(-1);
    }

    sdb::CarConfig625 IPCPSignalManager::getcarconfig625() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig625));
        }
        if (signal.has_value()){
            return sdb::CarConfig625(signal->value.int32Values[0]);
        }
        return sdb::CarConfig625(-1);
    }

    sdb::CarConfig626 IPCPSignalManager::getcarconfig626() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig626));
        }
        if (signal.has_value()){
            return sdb::CarConfig626(signal->value.int32Values[0]);
        }
        return sdb::CarConfig626(-1);
    }

    sdb::CarConfig627 IPCPSignalManager::getcarconfig627() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig627));
        }
        if (signal.has_value()){
            return sdb::CarConfig627(signal->value.int32Values[0]);
        }
        return sdb::CarConfig627(-1);
    }

    sdb::CarConfig628 IPCPSignalManager::getcarconfig628() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig628));
        }
        if (signal.has_value()){
            return sdb::CarConfig628(signal->value.int32Values[0]);
        }
        return sdb::CarConfig628(-1);
    }

    sdb::Carconfig629 IPCPSignalManager::getcarconfig629() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig629));
        }
        if (signal.has_value()){
            return sdb::Carconfig629(signal->value.int32Values[0]);
        }
        return sdb::Carconfig629(-1);
    }

    sdb::Carconfig630 IPCPSignalManager::getcarconfig630() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig630));
        }
        if (signal.has_value()){
            return sdb::Carconfig630(signal->value.int32Values[0]);
        }
        return sdb::Carconfig630(-1);
    }

    sdb::CarConfig631 IPCPSignalManager::getcarconfig631() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig631));
        }
        if (signal.has_value()){
            return sdb::CarConfig631(signal->value.int32Values[0]);
        }
        return sdb::CarConfig631(-1);
    }

    sdb::Carconfig632 IPCPSignalManager::getcarconfig632() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig632));
        }
        if (signal.has_value()){
            return sdb::Carconfig632(signal->value.int32Values[0]);
        }
        return sdb::Carconfig632(-1);
    }

    sdb::Carconfig633 IPCPSignalManager::getcarconfig633() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig633));
        }
        if (signal.has_value()){
            return sdb::Carconfig633(signal->value.int32Values[0]);
        }
        return sdb::Carconfig633(-1);
    }

    sdb::Carconfig634 IPCPSignalManager::getcarconfig634() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig634));
        }
        if (signal.has_value()){
            return sdb::Carconfig634(signal->value.int32Values[0]);
        }
        return sdb::Carconfig634(-1);
    }

    sdb::Carconfig635 IPCPSignalManager::getcarconfig635() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig635));
        }
        if (signal.has_value()){
            return sdb::Carconfig635(signal->value.int32Values[0]);
        }
        return sdb::Carconfig635(-1);
    }

    sdb::CarConfig636 IPCPSignalManager::getcarconfig636() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig636));
        }
        if (signal.has_value()){
            return sdb::CarConfig636(signal->value.int32Values[0]);
        }
        return sdb::CarConfig636(-1);
    }

    sdb::CarConfig637 IPCPSignalManager::getcarconfig637() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig637));
        }
        if (signal.has_value()){
            return sdb::CarConfig637(signal->value.int32Values[0]);
        }
        return sdb::CarConfig637(-1);
    }

    sdb::CarConfig638 IPCPSignalManager::getcarconfig638() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig638));
        }
        if (signal.has_value()){
            return sdb::CarConfig638(signal->value.int32Values[0]);
        }
        return sdb::CarConfig638(-1);
    }

    sdb::CarConfig639 IPCPSignalManager::getcarconfig639() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig639));
        }
        if (signal.has_value()){
            return sdb::CarConfig639(signal->value.int32Values[0]);
        }
        return sdb::CarConfig639(-1);
    }

    sdb::CarConfig640 IPCPSignalManager::getcarconfig640() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig640));
        }
        if (signal.has_value()){
            return sdb::CarConfig640(signal->value.int32Values[0]);
        }
        return sdb::CarConfig640(-1);
    }

    sdb::CarConfig641 IPCPSignalManager::getcarconfig641() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig641));
        }
        if (signal.has_value()){
            return sdb::CarConfig641(signal->value.int32Values[0]);
        }
        return sdb::CarConfig641(-1);
    }

    sdb::CarConfig642 IPCPSignalManager::getcarconfig642() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig642));
        }
        if (signal.has_value()){
            return sdb::CarConfig642(signal->value.int32Values[0]);
        }
        return sdb::CarConfig642(-1);
    }

    sdb::Carconfig643 IPCPSignalManager::getcarconfig643() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig643));
        }
        if (signal.has_value()){
            return sdb::Carconfig643(signal->value.int32Values[0]);
        }
        return sdb::Carconfig643(-1);
    }

    sdb::CarConfig644 IPCPSignalManager::getcarconfig644() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig644));
        }
        if (signal.has_value()){
            return sdb::CarConfig644(signal->value.int32Values[0]);
        }
        return sdb::CarConfig644(-1);
    }

    sdb::Carconfig645 IPCPSignalManager::getcarconfig645() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig645));
        }
        if (signal.has_value()){
            return sdb::Carconfig645(signal->value.int32Values[0]);
        }
        return sdb::Carconfig645(-1);
    }

    sdb::Carconfig646 IPCPSignalManager::getcarconfig646() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig646));
        }
        if (signal.has_value()){
            return sdb::Carconfig646(signal->value.int32Values[0]);
        }
        return sdb::Carconfig646(-1);
    }

    sdb::CarConfig647 IPCPSignalManager::getcarconfig647() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig647));
        }
        if (signal.has_value()){
            return sdb::CarConfig647(signal->value.int32Values[0]);
        }
        return sdb::CarConfig647(-1);
    }

    sdb::CarConfig648 IPCPSignalManager::getcarconfig648() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig648));
        }
        if (signal.has_value()){
            return sdb::CarConfig648(signal->value.int32Values[0]);
        }
        return sdb::CarConfig648(-1);
    }

    sdb::Carconfig649 IPCPSignalManager::getcarconfig649() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig649));
        }
        if (signal.has_value()){
            return sdb::Carconfig649(signal->value.int32Values[0]);
        }
        return sdb::Carconfig649(-1);
    }

    sdb::CarConfig650 IPCPSignalManager::getcarconfig650() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig650));
        }
        if (signal.has_value()){
            return sdb::CarConfig650(signal->value.int32Values[0]);
        }
        return sdb::CarConfig650(-1);
    }

    sdb::Carconfig651 IPCPSignalManager::getcarconfig651() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig651));
        }
        if (signal.has_value()){
            return sdb::Carconfig651(signal->value.int32Values[0]);
        }
        return sdb::Carconfig651(-1);
    }

    sdb::Carconfig652 IPCPSignalManager::getcarconfig652() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig652));
        }
        if (signal.has_value()){
            return sdb::Carconfig652(signal->value.int32Values[0]);
        }
        return sdb::Carconfig652(-1);
    }

    sdb::CarConfig653 IPCPSignalManager::getcarconfig653() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig653));
        }
        if (signal.has_value()){
            return sdb::CarConfig653(signal->value.int32Values[0]);
        }
        return sdb::CarConfig653(-1);
    }

    sdb::CarConfig654 IPCPSignalManager::getcarconfig654() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig654));
        }
        if (signal.has_value()){
            return sdb::CarConfig654(signal->value.int32Values[0]);
        }
        return sdb::CarConfig654(-1);
    }

    sdb::Carconfig655 IPCPSignalManager::getcarconfig655() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig655));
        }
        if (signal.has_value()){
            return sdb::Carconfig655(signal->value.int32Values[0]);
        }
        return sdb::Carconfig655(-1);
    }

    sdb::CarConfig656 IPCPSignalManager::getcarconfig656() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig656));
        }
        if (signal.has_value()){
            return sdb::CarConfig656(signal->value.int32Values[0]);
        }
        return sdb::CarConfig656(-1);
    }

    sdb::CarConfig657 IPCPSignalManager::getcarconfig657() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig657));
        }
        if (signal.has_value()){
            return sdb::CarConfig657(signal->value.int32Values[0]);
        }
        return sdb::CarConfig657(-1);
    }

    sdb::CarConfig658 IPCPSignalManager::getcarconfig658() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig658));
        }
        if (signal.has_value()){
            return sdb::CarConfig658(signal->value.int32Values[0]);
        }
        return sdb::CarConfig658(-1);
    }

    sdb::Carconfig659 IPCPSignalManager::getcarconfig659() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig659));
        }
        if (signal.has_value()){
            return sdb::Carconfig659(signal->value.int32Values[0]);
        }
        return sdb::Carconfig659(-1);
    }

    sdb::Carconfig660 IPCPSignalManager::getcarconfig660() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig660));
        }
        if (signal.has_value()){
            return sdb::Carconfig660(signal->value.int32Values[0]);
        }
        return sdb::Carconfig660(-1);
    }

    sdb::CarConfig661 IPCPSignalManager::getcarconfig661() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig661));
        }
        if (signal.has_value()){
            return sdb::CarConfig661(signal->value.int32Values[0]);
        }
        return sdb::CarConfig661(-1);
    }

    sdb::CarConfig662 IPCPSignalManager::getcarconfig662() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig662));
        }
        if (signal.has_value()){
            return sdb::CarConfig662(signal->value.int32Values[0]);
        }
        return sdb::CarConfig662(-1);
    }

    sdb::CarConfig663 IPCPSignalManager::getcarconfig663() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig663));
        }
        if (signal.has_value()){
            return sdb::CarConfig663(signal->value.int32Values[0]);
        }
        return sdb::CarConfig663(-1);
    }

    sdb::CarConfig664 IPCPSignalManager::getcarconfig664() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig664));
        }
        if (signal.has_value()){
            return sdb::CarConfig664(signal->value.int32Values[0]);
        }
        return sdb::CarConfig664(-1);
    }

    sdb::CarConfig665 IPCPSignalManager::getcarconfig665() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig665));
        }
        if (signal.has_value()){
            return sdb::CarConfig665(signal->value.int32Values[0]);
        }
        return sdb::CarConfig665(-1);
    }

    sdb::CarConfig666 IPCPSignalManager::getcarconfig666() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig666));
        }
        if (signal.has_value()){
            return sdb::CarConfig666(signal->value.int32Values[0]);
        }
        return sdb::CarConfig666(-1);
    }

    sdb::CarConfig667 IPCPSignalManager::getcarconfig667() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig667));
        }
        if (signal.has_value()){
            return sdb::CarConfig667(signal->value.int32Values[0]);
        }
        return sdb::CarConfig667(-1);
    }

    sdb::CarConfig668 IPCPSignalManager::getcarconfig668() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig668));
        }
        if (signal.has_value()){
            return sdb::CarConfig668(signal->value.int32Values[0]);
        }
        return sdb::CarConfig668(-1);
    }

    sdb::CarConfig669 IPCPSignalManager::getcarconfig669() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig669));
        }
        if (signal.has_value()){
            return sdb::CarConfig669(signal->value.int32Values[0]);
        }
        return sdb::CarConfig669(-1);
    }

    sdb::Carconfig670 IPCPSignalManager::getcarconfig670() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig670));
        }
        if (signal.has_value()){
            return sdb::Carconfig670(signal->value.int32Values[0]);
        }
        return sdb::Carconfig670(-1);
    }

    sdb::CarConfig671 IPCPSignalManager::getcarconfig671() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig671));
        }
        if (signal.has_value()){
            return sdb::CarConfig671(signal->value.int32Values[0]);
        }
        return sdb::CarConfig671(-1);
    }

    sdb::CarConfig672 IPCPSignalManager::getcarconfig672() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig672));
        }
        if (signal.has_value()){
            return sdb::CarConfig672(signal->value.int32Values[0]);
        }
        return sdb::CarConfig672(-1);
    }

    sdb::CarConfig673 IPCPSignalManager::getcarconfig673() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig673));
        }
        if (signal.has_value()){
            return sdb::CarConfig673(signal->value.int32Values[0]);
        }
        return sdb::CarConfig673(-1);
    }

    sdb::Carconfig674 IPCPSignalManager::getcarconfig674() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig674));
        }
        if (signal.has_value()){
            return sdb::Carconfig674(signal->value.int32Values[0]);
        }
        return sdb::Carconfig674(-1);
    }

    sdb::CarConfig675 IPCPSignalManager::getcarconfig675() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig675));
        }
        if (signal.has_value()){
            return sdb::CarConfig675(signal->value.int32Values[0]);
        }
        return sdb::CarConfig675(-1);
    }

    sdb::CarConfig676 IPCPSignalManager::getcarconfig676() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig676));
        }
        if (signal.has_value()){
            return sdb::CarConfig676(signal->value.int32Values[0]);
        }
        return sdb::CarConfig676(-1);
    }

    sdb::CarConfig677 IPCPSignalManager::getcarconfig677() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig677));
        }
        if (signal.has_value()){
            return sdb::CarConfig677(signal->value.int32Values[0]);
        }
        return sdb::CarConfig677(-1);
    }

    sdb::CarConfig678 IPCPSignalManager::getcarconfig678() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig678));
        }
        if (signal.has_value()){
            return sdb::CarConfig678(signal->value.int32Values[0]);
        }
        return sdb::CarConfig678(-1);
    }

    sdb::Carconfig679 IPCPSignalManager::getcarconfig679() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig679));
        }
        if (signal.has_value()){
            return sdb::Carconfig679(signal->value.int32Values[0]);
        }
        return sdb::Carconfig679(-1);
    }

    sdb::CarConfig680 IPCPSignalManager::getcarconfig680() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig680));
        }
        if (signal.has_value()){
            return sdb::CarConfig680(signal->value.int32Values[0]);
        }
        return sdb::CarConfig680(-1);
    }

    sdb::CarConfig681 IPCPSignalManager::getcarconfig681() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig681));
        }
        if (signal.has_value()){
            return sdb::CarConfig681(signal->value.int32Values[0]);
        }
        return sdb::CarConfig681(-1);
    }

    sdb::CarConfig682 IPCPSignalManager::getcarconfig682() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig682));
        }
        if (signal.has_value()){
            return sdb::CarConfig682(signal->value.int32Values[0]);
        }
        return sdb::CarConfig682(-1);
    }

    sdb::CarConfig683 IPCPSignalManager::getcarconfig683() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig683));
        }
        if (signal.has_value()){
            return sdb::CarConfig683(signal->value.int32Values[0]);
        }
        return sdb::CarConfig683(-1);
    }

    sdb::Carconfig684 IPCPSignalManager::getcarconfig684() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig684));
        }
        if (signal.has_value()){
            return sdb::Carconfig684(signal->value.int32Values[0]);
        }
        return sdb::Carconfig684(-1);
    }

    sdb::Carconfig685 IPCPSignalManager::getcarconfig685() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig685));
        }
        if (signal.has_value()){
            return sdb::Carconfig685(signal->value.int32Values[0]);
        }
        return sdb::Carconfig685(-1);
    }

    sdb::Carconfig686 IPCPSignalManager::getcarconfig686() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig686));
        }
        if (signal.has_value()){
            return sdb::Carconfig686(signal->value.int32Values[0]);
        }
        return sdb::Carconfig686(-1);
    }

    sdb::Carconfig687 IPCPSignalManager::getcarconfig687() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig687));
        }
        if (signal.has_value()){
            return sdb::Carconfig687(signal->value.int32Values[0]);
        }
        return sdb::Carconfig687(-1);
    }

    sdb::CarConfig688 IPCPSignalManager::getcarconfig688() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig688));
        }
        if (signal.has_value()){
            return sdb::CarConfig688(signal->value.int32Values[0]);
        }
        return sdb::CarConfig688(-1);
    }

    sdb::Carconfig689 IPCPSignalManager::getcarconfig689() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig689));
        }
        if (signal.has_value()){
            return sdb::Carconfig689(signal->value.int32Values[0]);
        }
        return sdb::Carconfig689(-1);
    }

    sdb::Carconfig690 IPCPSignalManager::getcarconfig690() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig690));
        }
        if (signal.has_value()){
            return sdb::Carconfig690(signal->value.int32Values[0]);
        }
        return sdb::Carconfig690(-1);
    }

    sdb::Carconfig691 IPCPSignalManager::getcarconfig691() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig691));
        }
        if (signal.has_value()){
            return sdb::Carconfig691(signal->value.int32Values[0]);
        }
        return sdb::Carconfig691(-1);
    }

    sdb::Carconfig692 IPCPSignalManager::getcarconfig692() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig692));
        }
        if (signal.has_value()){
            return sdb::Carconfig692(signal->value.int32Values[0]);
        }
        return sdb::Carconfig692(-1);
    }

    sdb::Carconfig693 IPCPSignalManager::getcarconfig693() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig693));
        }
        if (signal.has_value()){
            return sdb::Carconfig693(signal->value.int32Values[0]);
        }
        return sdb::Carconfig693(-1);
    }

    sdb::Carconfig694 IPCPSignalManager::getcarconfig694() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig694));
        }
        if (signal.has_value()){
            return sdb::Carconfig694(signal->value.int32Values[0]);
        }
        return sdb::Carconfig694(-1);
    }

    sdb::CarConfig695 IPCPSignalManager::getcarconfig695() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig695));
        }
        if (signal.has_value()){
            return sdb::CarConfig695(signal->value.int32Values[0]);
        }
        return sdb::CarConfig695(-1);
    }

    sdb::Carconfig696 IPCPSignalManager::getcarconfig696() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig696));
        }
        if (signal.has_value()){
            return sdb::Carconfig696(signal->value.int32Values[0]);
        }
        return sdb::Carconfig696(-1);
    }

    sdb::Carconfig697 IPCPSignalManager::getcarconfig697() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig697));
        }
        if (signal.has_value()){
            return sdb::Carconfig697(signal->value.int32Values[0]);
        }
        return sdb::Carconfig697(-1);
    }

    sdb::Carconfig698 IPCPSignalManager::getcarconfig698() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig698));
        }
        if (signal.has_value()){
            return sdb::Carconfig698(signal->value.int32Values[0]);
        }
        return sdb::Carconfig698(-1);
    }

    sdb::Carconfig699 IPCPSignalManager::getcarconfig699() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig699));
        }
        if (signal.has_value()){
            return sdb::Carconfig699(signal->value.int32Values[0]);
        }
        return sdb::Carconfig699(-1);
    }

    sdb::Carconfig700 IPCPSignalManager::getcarconfig700() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig700));
        }
        if (signal.has_value()){
            return sdb::Carconfig700(signal->value.int32Values[0]);
        }
        return sdb::Carconfig700(-1);
    }

    sdb::CarConfig701 IPCPSignalManager::getcarconfig701() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig701));
        }
        if (signal.has_value()){
            return sdb::CarConfig701(signal->value.int32Values[0]);
        }
        return sdb::CarConfig701(-1);
    }

    sdb::Carconfig702 IPCPSignalManager::getcarconfig702() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig702));
        }
        if (signal.has_value()){
            return sdb::Carconfig702(signal->value.int32Values[0]);
        }
        return sdb::Carconfig702(-1);
    }

    sdb::Carconfig703 IPCPSignalManager::getcarconfig703() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig703));
        }
        if (signal.has_value()){
            return sdb::Carconfig703(signal->value.int32Values[0]);
        }
        return sdb::Carconfig703(-1);
    }

    sdb::Carconfig704 IPCPSignalManager::getcarconfig704() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig704));
        }
        if (signal.has_value()){
            return sdb::Carconfig704(signal->value.int32Values[0]);
        }
        return sdb::Carconfig704(-1);
    }

    sdb::Carconfig705 IPCPSignalManager::getcarconfig705() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig705));
        }
        if (signal.has_value()){
            return sdb::Carconfig705(signal->value.int32Values[0]);
        }
        return sdb::Carconfig705(-1);
    }

    sdb::Carconfig706 IPCPSignalManager::getcarconfig706() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig706));
        }
        if (signal.has_value()){
            return sdb::Carconfig706(signal->value.int32Values[0]);
        }
        return sdb::Carconfig706(-1);
    }

    sdb::Carconfig707 IPCPSignalManager::getcarconfig707() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig707));
        }
        if (signal.has_value()){
            return sdb::Carconfig707(signal->value.int32Values[0]);
        }
        return sdb::Carconfig707(-1);
    }

    sdb::Carconfig708 IPCPSignalManager::getcarconfig708() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig708));
        }
        if (signal.has_value()){
            return sdb::Carconfig708(signal->value.int32Values[0]);
        }
        return sdb::Carconfig708(-1);
    }

    sdb::Carconfig709 IPCPSignalManager::getcarconfig709() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig709));
        }
        if (signal.has_value()){
            return sdb::Carconfig709(signal->value.int32Values[0]);
        }
        return sdb::Carconfig709(-1);
    }

    sdb::Carconfig710 IPCPSignalManager::getcarconfig710() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig710));
        }
        if (signal.has_value()){
            return sdb::Carconfig710(signal->value.int32Values[0]);
        }
        return sdb::Carconfig710(-1);
    }

    sdb::Carconfig711 IPCPSignalManager::getcarconfig711() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig711));
        }
        if (signal.has_value()){
            return sdb::Carconfig711(signal->value.int32Values[0]);
        }
        return sdb::Carconfig711(-1);
    }

    sdb::Carconfig712 IPCPSignalManager::getcarconfig712() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig712));
        }
        if (signal.has_value()){
            return sdb::Carconfig712(signal->value.int32Values[0]);
        }
        return sdb::Carconfig712(-1);
    }

    sdb::Carconfig713 IPCPSignalManager::getcarconfig713() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig713));
        }
        if (signal.has_value()){
            return sdb::Carconfig713(signal->value.int32Values[0]);
        }
        return sdb::Carconfig713(-1);
    }

    sdb::Carconfig714 IPCPSignalManager::getcarconfig714() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig714));
        }
        if (signal.has_value()){
            return sdb::Carconfig714(signal->value.int32Values[0]);
        }
        return sdb::Carconfig714(-1);
    }

    sdb::Carconfig715 IPCPSignalManager::getcarconfig715() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig715));
        }
        if (signal.has_value()){
            return sdb::Carconfig715(signal->value.int32Values[0]);
        }
        return sdb::Carconfig715(-1);
    }

    sdb::Carconfig716 IPCPSignalManager::getcarconfig716() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig716));
        }
        if (signal.has_value()){
            return sdb::Carconfig716(signal->value.int32Values[0]);
        }
        return sdb::Carconfig716(-1);
    }

    sdb::Carconfig717 IPCPSignalManager::getcarconfig717() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig717));
        }
        if (signal.has_value()){
            return sdb::Carconfig717(signal->value.int32Values[0]);
        }
        return sdb::Carconfig717(-1);
    }

    sdb::Carconfig718 IPCPSignalManager::getcarconfig718() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig718));
        }
        if (signal.has_value()){
            return sdb::Carconfig718(signal->value.int32Values[0]);
        }
        return sdb::Carconfig718(-1);
    }

    sdb::Carconfig719 IPCPSignalManager::getcarconfig719() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig719));
        }
        if (signal.has_value()){
            return sdb::Carconfig719(signal->value.int32Values[0]);
        }
        return sdb::Carconfig719(-1);
    }

    sdb::Carconfig720 IPCPSignalManager::getcarconfig720() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig720));
        }
        if (signal.has_value()){
            return sdb::Carconfig720(signal->value.int32Values[0]);
        }
        return sdb::Carconfig720(-1);
    }

    sdb::CarConfig721 IPCPSignalManager::getcarconfig721() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig721));
        }
        if (signal.has_value()){
            return sdb::CarConfig721(signal->value.int32Values[0]);
        }
        return sdb::CarConfig721(-1);
    }

    sdb::Carconfig722 IPCPSignalManager::getcarconfig722() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig722));
        }
        if (signal.has_value()){
            return sdb::Carconfig722(signal->value.int32Values[0]);
        }
        return sdb::Carconfig722(-1);
    }

    sdb::Carconfig723 IPCPSignalManager::getcarconfig723() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig723));
        }
        if (signal.has_value()){
            return sdb::Carconfig723(signal->value.int32Values[0]);
        }
        return sdb::Carconfig723(-1);
    }

    sdb::Carconfig724 IPCPSignalManager::getcarconfig724() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig724));
        }
        if (signal.has_value()){
            return sdb::Carconfig724(signal->value.int32Values[0]);
        }
        return sdb::Carconfig724(-1);
    }

    sdb::Carconfig725 IPCPSignalManager::getcarconfig725() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig725));
        }
        if (signal.has_value()){
            return sdb::Carconfig725(signal->value.int32Values[0]);
        }
        return sdb::Carconfig725(-1);
    }

    sdb::Carconfig726 IPCPSignalManager::getcarconfig726() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig726));
        }
        if (signal.has_value()){
            return sdb::Carconfig726(signal->value.int32Values[0]);
        }
        return sdb::Carconfig726(-1);
    }

    sdb::Carconfig727 IPCPSignalManager::getcarconfig727() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig727));
        }
        if (signal.has_value()){
            return sdb::Carconfig727(signal->value.int32Values[0]);
        }
        return sdb::Carconfig727(-1);
    }

    sdb::Carconfig728 IPCPSignalManager::getcarconfig728() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig728));
        }
        if (signal.has_value()){
            return sdb::Carconfig728(signal->value.int32Values[0]);
        }
        return sdb::Carconfig728(-1);
    }

    sdb::Carconfig729 IPCPSignalManager::getcarconfig729() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig729));
        }
        if (signal.has_value()){
            return sdb::Carconfig729(signal->value.int32Values[0]);
        }
        return sdb::Carconfig729(-1);
    }

    sdb::Carconfig730 IPCPSignalManager::getcarconfig730() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig730));
        }
        if (signal.has_value()){
            return sdb::Carconfig730(signal->value.int32Values[0]);
        }
        return sdb::Carconfig730(-1);
    }

    sdb::Carconfig731 IPCPSignalManager::getcarconfig731() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig731));
        }
        if (signal.has_value()){
            return sdb::Carconfig731(signal->value.int32Values[0]);
        }
        return sdb::Carconfig731(-1);
    }

    sdb::CarConfig732 IPCPSignalManager::getcarconfig732() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig732));
        }
        if (signal.has_value()){
            return sdb::CarConfig732(signal->value.int32Values[0]);
        }
        return sdb::CarConfig732(-1);
    }

    sdb::Carconfig733 IPCPSignalManager::getcarconfig733() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig733));
        }
        if (signal.has_value()){
            return sdb::Carconfig733(signal->value.int32Values[0]);
        }
        return sdb::Carconfig733(-1);
    }

    sdb::Carconfig734 IPCPSignalManager::getcarconfig734() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig734));
        }
        if (signal.has_value()){
            return sdb::Carconfig734(signal->value.int32Values[0]);
        }
        return sdb::Carconfig734(-1);
    }

    sdb::Carconfig735 IPCPSignalManager::getcarconfig735() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig735));
        }
        if (signal.has_value()){
            return sdb::Carconfig735(signal->value.int32Values[0]);
        }
        return sdb::Carconfig735(-1);
    }

    sdb::Carconfig736 IPCPSignalManager::getcarconfig736() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig736));
        }
        if (signal.has_value()){
            return sdb::Carconfig736(signal->value.int32Values[0]);
        }
        return sdb::Carconfig736(-1);
    }

    sdb::Carconfig737 IPCPSignalManager::getcarconfig737() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig737));
        }
        if (signal.has_value()){
            return sdb::Carconfig737(signal->value.int32Values[0]);
        }
        return sdb::Carconfig737(-1);
    }

    sdb::Carconfig738 IPCPSignalManager::getcarconfig738() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig738));
        }
        if (signal.has_value()){
            return sdb::Carconfig738(signal->value.int32Values[0]);
        }
        return sdb::Carconfig738(-1);
    }

    sdb::Carconfig739 IPCPSignalManager::getcarconfig739() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig739));
        }
        if (signal.has_value()){
            return sdb::Carconfig739(signal->value.int32Values[0]);
        }
        return sdb::Carconfig739(-1);
    }

    sdb::Carconfig740 IPCPSignalManager::getcarconfig740() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig740));
        }
        if (signal.has_value()){
            return sdb::Carconfig740(signal->value.int32Values[0]);
        }
        return sdb::Carconfig740(-1);
    }

    sdb::CarConfig741 IPCPSignalManager::getcarconfig741() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig741));
        }
        if (signal.has_value()){
            return sdb::CarConfig741(signal->value.int32Values[0]);
        }
        return sdb::CarConfig741(-1);
    }

    sdb::Carconfig742 IPCPSignalManager::getcarconfig742() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig742));
        }
        if (signal.has_value()){
            return sdb::Carconfig742(signal->value.int32Values[0]);
        }
        return sdb::Carconfig742(-1);
    }

    sdb::Carconfig743 IPCPSignalManager::getcarconfig743() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig743));
        }
        if (signal.has_value()){
            return sdb::Carconfig743(signal->value.int32Values[0]);
        }
        return sdb::Carconfig743(-1);
    }

    sdb::Carconfig744 IPCPSignalManager::getcarconfig744() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig744));
        }
        if (signal.has_value()){
            return sdb::Carconfig744(signal->value.int32Values[0]);
        }
        return sdb::Carconfig744(-1);
    }

    sdb::Carconfig745 IPCPSignalManager::getcarconfig745() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig745));
        }
        if (signal.has_value()){
            return sdb::Carconfig745(signal->value.int32Values[0]);
        }
        return sdb::Carconfig745(-1);
    }

    sdb::Carconfig746 IPCPSignalManager::getcarconfig746() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig746));
        }
        if (signal.has_value()){
            return sdb::Carconfig746(signal->value.int32Values[0]);
        }
        return sdb::Carconfig746(-1);
    }

    sdb::Carconfig747 IPCPSignalManager::getcarconfig747() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig747));
        }
        if (signal.has_value()){
            return sdb::Carconfig747(signal->value.int32Values[0]);
        }
        return sdb::Carconfig747(-1);
    }

    sdb::Carconfig748 IPCPSignalManager::getcarconfig748() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig748));
        }
        if (signal.has_value()){
            return sdb::Carconfig748(signal->value.int32Values[0]);
        }
        return sdb::Carconfig748(-1);
    }

    sdb::Carconfig749 IPCPSignalManager::getcarconfig749() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig749));
        }
        if (signal.has_value()){
            return sdb::Carconfig749(signal->value.int32Values[0]);
        }
        return sdb::Carconfig749(-1);
    }

    sdb::Carconfig750 IPCPSignalManager::getcarconfig750() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig750));
        }
        if (signal.has_value()){
            return sdb::Carconfig750(signal->value.int32Values[0]);
        }
        return sdb::Carconfig750(-1);
    }

    sdb::Carconfig751 IPCPSignalManager::getcarconfig751() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig751));
        }
        if (signal.has_value()){
            return sdb::Carconfig751(signal->value.int32Values[0]);
        }
        return sdb::Carconfig751(-1);
    }

    sdb::Carconfig752 IPCPSignalManager::getcarconfig752() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig752));
        }
        if (signal.has_value()){
            return sdb::Carconfig752(signal->value.int32Values[0]);
        }
        return sdb::Carconfig752(-1);
    }

    sdb::Carconfig753 IPCPSignalManager::getcarconfig753() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig753));
        }
        if (signal.has_value()){
            return sdb::Carconfig753(signal->value.int32Values[0]);
        }
        return sdb::Carconfig753(-1);
    }

    sdb::Carconfig754 IPCPSignalManager::getcarconfig754() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig754));
        }
        if (signal.has_value()){
            return sdb::Carconfig754(signal->value.int32Values[0]);
        }
        return sdb::Carconfig754(-1);
    }

    sdb::Carconfig755 IPCPSignalManager::getcarconfig755() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig755));
        }
        if (signal.has_value()){
            return sdb::Carconfig755(signal->value.int32Values[0]);
        }
        return sdb::Carconfig755(-1);
    }

    sdb::CarConfig756 IPCPSignalManager::getcarconfig756() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig756));
        }
        if (signal.has_value()){
            return sdb::CarConfig756(signal->value.int32Values[0]);
        }
        return sdb::CarConfig756(-1);
    }

    sdb::Carconfig757 IPCPSignalManager::getcarconfig757() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig757));
        }
        if (signal.has_value()){
            return sdb::Carconfig757(signal->value.int32Values[0]);
        }
        return sdb::Carconfig757(-1);
    }

    sdb::Carconfig758 IPCPSignalManager::getcarconfig758() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig758));
        }
        if (signal.has_value()){
            return sdb::Carconfig758(signal->value.int32Values[0]);
        }
        return sdb::Carconfig758(-1);
    }

    sdb::Carconfig759 IPCPSignalManager::getcarconfig759() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig759));
        }
        if (signal.has_value()){
            return sdb::Carconfig759(signal->value.int32Values[0]);
        }
        return sdb::Carconfig759(-1);
    }

    sdb::Carconfig760 IPCPSignalManager::getcarconfig760() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig760));
        }
        if (signal.has_value()){
            return sdb::Carconfig760(signal->value.int32Values[0]);
        }
        return sdb::Carconfig760(-1);
    }

    sdb::Carconfig761 IPCPSignalManager::getcarconfig761() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig761));
        }
        if (signal.has_value()){
            return sdb::Carconfig761(signal->value.int32Values[0]);
        }
        return sdb::Carconfig761(-1);
    }

    sdb::Carconfig762 IPCPSignalManager::getcarconfig762() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig762));
        }
        if (signal.has_value()){
            return sdb::Carconfig762(signal->value.int32Values[0]);
        }
        return sdb::Carconfig762(-1);
    }

    sdb::Carconfig763 IPCPSignalManager::getcarconfig763() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig763));
        }
        if (signal.has_value()){
            return sdb::Carconfig763(signal->value.int32Values[0]);
        }
        return sdb::Carconfig763(-1);
    }

    sdb::Carconfig764 IPCPSignalManager::getcarconfig764() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig764));
        }
        if (signal.has_value()){
            return sdb::Carconfig764(signal->value.int32Values[0]);
        }
        return sdb::Carconfig764(-1);
    }

    sdb::Carconfig765 IPCPSignalManager::getcarconfig765() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig765));
        }
        if (signal.has_value()){
            return sdb::Carconfig765(signal->value.int32Values[0]);
        }
        return sdb::Carconfig765(-1);
    }

    sdb::Carconfig766 IPCPSignalManager::getcarconfig766() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig766));
        }
        if (signal.has_value()){
            return sdb::Carconfig766(signal->value.int32Values[0]);
        }
        return sdb::Carconfig766(-1);
    }

    sdb::Carconfig767 IPCPSignalManager::getcarconfig767() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig767));
        }
        if (signal.has_value()){
            return sdb::Carconfig767(signal->value.int32Values[0]);
        }
        return sdb::Carconfig767(-1);
    }

    sdb::Carconfig768 IPCPSignalManager::getcarconfig768() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig768));
        }
        if (signal.has_value()){
            return sdb::Carconfig768(signal->value.int32Values[0]);
        }
        return sdb::Carconfig768(-1);
    }

    sdb::Carconfig769 IPCPSignalManager::getcarconfig769() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig769));
        }
        if (signal.has_value()){
            return sdb::Carconfig769(signal->value.int32Values[0]);
        }
        return sdb::Carconfig769(-1);
    }

    sdb::Carconfig770 IPCPSignalManager::getcarconfig770() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig770));
        }
        if (signal.has_value()){
            return sdb::Carconfig770(signal->value.int32Values[0]);
        }
        return sdb::Carconfig770(-1);
    }

    sdb::Carconfig771 IPCPSignalManager::getcarconfig771() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig771));
        }
        if (signal.has_value()){
            return sdb::Carconfig771(signal->value.int32Values[0]);
        }
        return sdb::Carconfig771(-1);
    }

    sdb::Carconfig772 IPCPSignalManager::getcarconfig772() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig772));
        }
        if (signal.has_value()){
            return sdb::Carconfig772(signal->value.int32Values[0]);
        }
        return sdb::Carconfig772(-1);
    }

    sdb::Carconfig773 IPCPSignalManager::getcarconfig773() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig773));
        }
        if (signal.has_value()){
            return sdb::Carconfig773(signal->value.int32Values[0]);
        }
        return sdb::Carconfig773(-1);
    }

    sdb::Carconfig774 IPCPSignalManager::getcarconfig774() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig774));
        }
        if (signal.has_value()){
            return sdb::Carconfig774(signal->value.int32Values[0]);
        }
        return sdb::Carconfig774(-1);
    }

    sdb::Carconfig775 IPCPSignalManager::getcarconfig775() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig775));
        }
        if (signal.has_value()){
            return sdb::Carconfig775(signal->value.int32Values[0]);
        }
        return sdb::Carconfig775(-1);
    }

    sdb::Carconfig776 IPCPSignalManager::getcarconfig776() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig776));
        }
        if (signal.has_value()){
            return sdb::Carconfig776(signal->value.int32Values[0]);
        }
        return sdb::Carconfig776(-1);
    }

    sdb::Carconfig777 IPCPSignalManager::getcarconfig777() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig777));
        }
        if (signal.has_value()){
            return sdb::Carconfig777(signal->value.int32Values[0]);
        }
        return sdb::Carconfig777(-1);
    }

    sdb::Carconfig778 IPCPSignalManager::getcarconfig778() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig778));
        }
        if (signal.has_value()){
            return sdb::Carconfig778(signal->value.int32Values[0]);
        }
        return sdb::Carconfig778(-1);
    }

    sdb::Carconfig779 IPCPSignalManager::getcarconfig779() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig779));
        }
        if (signal.has_value()){
            return sdb::Carconfig779(signal->value.int32Values[0]);
        }
        return sdb::Carconfig779(-1);
    }

    sdb::Carconfig780 IPCPSignalManager::getcarconfig780() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig780));
        }
        if (signal.has_value()){
            return sdb::Carconfig780(signal->value.int32Values[0]);
        }
        return sdb::Carconfig780(-1);
    }

    sdb::Carconfig781 IPCPSignalManager::getcarconfig781() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig781));
        }
        if (signal.has_value()){
            return sdb::Carconfig781(signal->value.int32Values[0]);
        }
        return sdb::Carconfig781(-1);
    }

    sdb::Carconfig782 IPCPSignalManager::getcarconfig782() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig782));
        }
        if (signal.has_value()){
            return sdb::Carconfig782(signal->value.int32Values[0]);
        }
        return sdb::Carconfig782(-1);
    }

    sdb::Carconfig783 IPCPSignalManager::getcarconfig783() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig783));
        }
        if (signal.has_value()){
            return sdb::Carconfig783(signal->value.int32Values[0]);
        }
        return sdb::Carconfig783(-1);
    }

    sdb::Carconfig784 IPCPSignalManager::getcarconfig784() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig784));
        }
        if (signal.has_value()){
            return sdb::Carconfig784(signal->value.int32Values[0]);
        }
        return sdb::Carconfig784(-1);
    }

    sdb::Carconfig785 IPCPSignalManager::getcarconfig785() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig785));
        }
        if (signal.has_value()){
            return sdb::Carconfig785(signal->value.int32Values[0]);
        }
        return sdb::Carconfig785(-1);
    }

    sdb::Carconfig786 IPCPSignalManager::getcarconfig786() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig786));
        }
        if (signal.has_value()){
            return sdb::Carconfig786(signal->value.int32Values[0]);
        }
        return sdb::Carconfig786(-1);
    }

    sdb::Carconfig787 IPCPSignalManager::getcarconfig787() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig787));
        }
        if (signal.has_value()){
            return sdb::Carconfig787(signal->value.int32Values[0]);
        }
        return sdb::Carconfig787(-1);
    }

    sdb::Carconfig788 IPCPSignalManager::getcarconfig788() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig788));
        }
        if (signal.has_value()){
            return sdb::Carconfig788(signal->value.int32Values[0]);
        }
        return sdb::Carconfig788(-1);
    }

    sdb::Carconfig789 IPCPSignalManager::getcarconfig789() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig789));
        }
        if (signal.has_value()){
            return sdb::Carconfig789(signal->value.int32Values[0]);
        }
        return sdb::Carconfig789(-1);
    }

    sdb::Carconfig790 IPCPSignalManager::getcarconfig790() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig790));
        }
        if (signal.has_value()){
            return sdb::Carconfig790(signal->value.int32Values[0]);
        }
        return sdb::Carconfig790(-1);
    }

    sdb::Carconfig791 IPCPSignalManager::getcarconfig791() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig791));
        }
        if (signal.has_value()){
            return sdb::Carconfig791(signal->value.int32Values[0]);
        }
        return sdb::Carconfig791(-1);
    }

    sdb::Carconfig792 IPCPSignalManager::getcarconfig792() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig792));
        }
        if (signal.has_value()){
            return sdb::Carconfig792(signal->value.int32Values[0]);
        }
        return sdb::Carconfig792(-1);
    }

    sdb::Carconfig793 IPCPSignalManager::getcarconfig793() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig793));
        }
        if (signal.has_value()){
            return sdb::Carconfig793(signal->value.int32Values[0]);
        }
        return sdb::Carconfig793(-1);
    }

    sdb::Carconfig794 IPCPSignalManager::getcarconfig794() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig794));
        }
        if (signal.has_value()){
            return sdb::Carconfig794(signal->value.int32Values[0]);
        }
        return sdb::Carconfig794(-1);
    }

    sdb::Carconfig795 IPCPSignalManager::getcarconfig795() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig795));
        }
        if (signal.has_value()){
            return sdb::Carconfig795(signal->value.int32Values[0]);
        }
        return sdb::Carconfig795(-1);
    }

    sdb::Carconfig796 IPCPSignalManager::getcarconfig796() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig796));
        }
        if (signal.has_value()){
            return sdb::Carconfig796(signal->value.int32Values[0]);
        }
        return sdb::Carconfig796(-1);
    }

    sdb::Carconfig797 IPCPSignalManager::getcarconfig797() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig797));
        }
        if (signal.has_value()){
            return sdb::Carconfig797(signal->value.int32Values[0]);
        }
        return sdb::Carconfig797(-1);
    }

    sdb::Carconfig798 IPCPSignalManager::getcarconfig798() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig798));
        }
        if (signal.has_value()){
            return sdb::Carconfig798(signal->value.int32Values[0]);
        }
        return sdb::Carconfig798(-1);
    }

    sdb::Carconfig799 IPCPSignalManager::getcarconfig799() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig799));
        }
        if (signal.has_value()){
            return sdb::Carconfig799(signal->value.int32Values[0]);
        }
        return sdb::Carconfig799(-1);
    }

    sdb::Carconfig800 IPCPSignalManager::getcarconfig800() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig800));
        }
        if (signal.has_value()){
            return sdb::Carconfig800(signal->value.int32Values[0]);
        }
        return sdb::Carconfig800(-1);
    }

    sdb::Carconfig801 IPCPSignalManager::getcarconfig801() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig801));
        }
        if (signal.has_value()){
            return sdb::Carconfig801(signal->value.int32Values[0]);
        }
        return sdb::Carconfig801(-1);
    }

    sdb::Carconfig802 IPCPSignalManager::getcarconfig802() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig802));
        }
        if (signal.has_value()){
            return sdb::Carconfig802(signal->value.int32Values[0]);
        }
        return sdb::Carconfig802(-1);
    }

    sdb::Carconfig803 IPCPSignalManager::getcarconfig803() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig803));
        }
        if (signal.has_value()){
            return sdb::Carconfig803(signal->value.int32Values[0]);
        }
        return sdb::Carconfig803(-1);
    }

    sdb::Carconfig804 IPCPSignalManager::getcarconfig804() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig804));
        }
        if (signal.has_value()){
            return sdb::Carconfig804(signal->value.int32Values[0]);
        }
        return sdb::Carconfig804(-1);
    }

    sdb::Carconfig805 IPCPSignalManager::getcarconfig805() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig805));
        }
        if (signal.has_value()){
            return sdb::Carconfig805(signal->value.int32Values[0]);
        }
        return sdb::Carconfig805(-1);
    }

    sdb::Carconfig806 IPCPSignalManager::getcarconfig806() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig806));
        }
        if (signal.has_value()){
            return sdb::Carconfig806(signal->value.int32Values[0]);
        }
        return sdb::Carconfig806(-1);
    }

    sdb::Carconfig807 IPCPSignalManager::getcarconfig807() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig807));
        }
        if (signal.has_value()){
            return sdb::Carconfig807(signal->value.int32Values[0]);
        }
        return sdb::Carconfig807(-1);
    }

    sdb::Carconfig808 IPCPSignalManager::getcarconfig808() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig808));
        }
        if (signal.has_value()){
            return sdb::Carconfig808(signal->value.int32Values[0]);
        }
        return sdb::Carconfig808(-1);
    }

    sdb::Carconfig809 IPCPSignalManager::getcarconfig809() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig809));
        }
        if (signal.has_value()){
            return sdb::Carconfig809(signal->value.int32Values[0]);
        }
        return sdb::Carconfig809(-1);
    }

    sdb::Carconfig810 IPCPSignalManager::getcarconfig810() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig810));
        }
        if (signal.has_value()){
            return sdb::Carconfig810(signal->value.int32Values[0]);
        }
        return sdb::Carconfig810(-1);
    }

    sdb::Carconfig811 IPCPSignalManager::getcarconfig811() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig811));
        }
        if (signal.has_value()){
            return sdb::Carconfig811(signal->value.int32Values[0]);
        }
        return sdb::Carconfig811(-1);
    }

    sdb::Carconfig812 IPCPSignalManager::getcarconfig812() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig812));
        }
        if (signal.has_value()){
            return sdb::Carconfig812(signal->value.int32Values[0]);
        }
        return sdb::Carconfig812(-1);
    }

    sdb::Carconfig813 IPCPSignalManager::getcarconfig813() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig813));
        }
        if (signal.has_value()){
            return sdb::Carconfig813(signal->value.int32Values[0]);
        }
        return sdb::Carconfig813(-1);
    }

    sdb::Carconfig814 IPCPSignalManager::getcarconfig814() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig814));
        }
        if (signal.has_value()){
            return sdb::Carconfig814(signal->value.int32Values[0]);
        }
        return sdb::Carconfig814(-1);
    }

    sdb::Carconfig815 IPCPSignalManager::getcarconfig815() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig815));
        }
        if (signal.has_value()){
            return sdb::Carconfig815(signal->value.int32Values[0]);
        }
        return sdb::Carconfig815(-1);
    }

    sdb::Carconfig816 IPCPSignalManager::getcarconfig816() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig816));
        }
        if (signal.has_value()){
            return sdb::Carconfig816(signal->value.int32Values[0]);
        }
        return sdb::Carconfig816(-1);
    }

    sdb::Carconfig817 IPCPSignalManager::getcarconfig817() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig817));
        }
        if (signal.has_value()){
            return sdb::Carconfig817(signal->value.int32Values[0]);
        }
        return sdb::Carconfig817(-1);
    }

    sdb::Carconfig818 IPCPSignalManager::getcarconfig818() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig818));
        }
        if (signal.has_value()){
            return sdb::Carconfig818(signal->value.int32Values[0]);
        }
        return sdb::Carconfig818(-1);
    }

    sdb::Carconfig819 IPCPSignalManager::getcarconfig819() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig819));
        }
        if (signal.has_value()){
            return sdb::Carconfig819(signal->value.int32Values[0]);
        }
        return sdb::Carconfig819(-1);
    }

    sdb::Carconfig820 IPCPSignalManager::getcarconfig820() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig820));
        }
        if (signal.has_value()){
            return sdb::Carconfig820(signal->value.int32Values[0]);
        }
        return sdb::Carconfig820(-1);
    }

    sdb::Carconfig821 IPCPSignalManager::getcarconfig821() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig821));
        }
        if (signal.has_value()){
            return sdb::Carconfig821(signal->value.int32Values[0]);
        }
        return sdb::Carconfig821(-1);
    }

    sdb::Carconfig822 IPCPSignalManager::getcarconfig822() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig822));
        }
        if (signal.has_value()){
            return sdb::Carconfig822(signal->value.int32Values[0]);
        }
        return sdb::Carconfig822(-1);
    }

    sdb::Carconfig823 IPCPSignalManager::getcarconfig823() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig823));
        }
        if (signal.has_value()){
            return sdb::Carconfig823(signal->value.int32Values[0]);
        }
        return sdb::Carconfig823(-1);
    }

    sdb::Carconfig824 IPCPSignalManager::getcarconfig824() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig824));
        }
        if (signal.has_value()){
            return sdb::Carconfig824(signal->value.int32Values[0]);
        }
        return sdb::Carconfig824(-1);
    }

    sdb::Carconfig825 IPCPSignalManager::getcarconfig825() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig825));
        }
        if (signal.has_value()){
            return sdb::Carconfig825(signal->value.int32Values[0]);
        }
        return sdb::Carconfig825(-1);
    }

    sdb::Carconfig826 IPCPSignalManager::getcarconfig826() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig826));
        }
        if (signal.has_value()){
            return sdb::Carconfig826(signal->value.int32Values[0]);
        }
        return sdb::Carconfig826(-1);
    }

    sdb::Carconfig827 IPCPSignalManager::getcarconfig827() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig827));
        }
        if (signal.has_value()){
            return sdb::Carconfig827(signal->value.int32Values[0]);
        }
        return sdb::Carconfig827(-1);
    }

    sdb::Carconfig828 IPCPSignalManager::getcarconfig828() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig828));
        }
        if (signal.has_value()){
            return sdb::Carconfig828(signal->value.int32Values[0]);
        }
        return sdb::Carconfig828(-1);
    }

    sdb::Carconfig829 IPCPSignalManager::getcarconfig829() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig829));
        }
        if (signal.has_value()){
            return sdb::Carconfig829(signal->value.int32Values[0]);
        }
        return sdb::Carconfig829(-1);
    }

    sdb::Carconfig830 IPCPSignalManager::getcarconfig830() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig830));
        }
        if (signal.has_value()){
            return sdb::Carconfig830(signal->value.int32Values[0]);
        }
        return sdb::Carconfig830(-1);
    }

    sdb::Carconfig831 IPCPSignalManager::getcarconfig831() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig831));
        }
        if (signal.has_value()){
            return sdb::Carconfig831(signal->value.int32Values[0]);
        }
        return sdb::Carconfig831(-1);
    }

    sdb::Carconfig832 IPCPSignalManager::getcarconfig832() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig832));
        }
        if (signal.has_value()){
            return sdb::Carconfig832(signal->value.int32Values[0]);
        }
        return sdb::Carconfig832(-1);
    }

    sdb::Carconfig833 IPCPSignalManager::getcarconfig833() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig833));
        }
        if (signal.has_value()){
            return sdb::Carconfig833(signal->value.int32Values[0]);
        }
        return sdb::Carconfig833(-1);
    }

    sdb::Carconfig834 IPCPSignalManager::getcarconfig834() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig834));
        }
        if (signal.has_value()){
            return sdb::Carconfig834(signal->value.int32Values[0]);
        }
        return sdb::Carconfig834(-1);
    }

    sdb::Carconfig835 IPCPSignalManager::getcarconfig835() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig835));
        }
        if (signal.has_value()){
            return sdb::Carconfig835(signal->value.int32Values[0]);
        }
        return sdb::Carconfig835(-1);
    }

    sdb::Carconfig836 IPCPSignalManager::getcarconfig836() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig836));
        }
        if (signal.has_value()){
            return sdb::Carconfig836(signal->value.int32Values[0]);
        }
        return sdb::Carconfig836(-1);
    }

    sdb::Carconfig837 IPCPSignalManager::getcarconfig837() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig837));
        }
        if (signal.has_value()){
            return sdb::Carconfig837(signal->value.int32Values[0]);
        }
        return sdb::Carconfig837(-1);
    }

    sdb::Carconfig838 IPCPSignalManager::getcarconfig838() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig838));
        }
        if (signal.has_value()){
            return sdb::Carconfig838(signal->value.int32Values[0]);
        }
        return sdb::Carconfig838(-1);
    }

    sdb::Carconfig839 IPCPSignalManager::getcarconfig839() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig839));
        }
        if (signal.has_value()){
            return sdb::Carconfig839(signal->value.int32Values[0]);
        }
        return sdb::Carconfig839(-1);
    }

    sdb::Carconfig840 IPCPSignalManager::getcarconfig840() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig840));
        }
        if (signal.has_value()){
            return sdb::Carconfig840(signal->value.int32Values[0]);
        }
        return sdb::Carconfig840(-1);
    }

    sdb::Carconfig841 IPCPSignalManager::getcarconfig841() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig841));
        }
        if (signal.has_value()){
            return sdb::Carconfig841(signal->value.int32Values[0]);
        }
        return sdb::Carconfig841(-1);
    }

    sdb::Carconfig842 IPCPSignalManager::getcarconfig842() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig842));
        }
        if (signal.has_value()){
            return sdb::Carconfig842(signal->value.int32Values[0]);
        }
        return sdb::Carconfig842(-1);
    }

    sdb::Carconfig843 IPCPSignalManager::getcarconfig843() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig843));
        }
        if (signal.has_value()){
            return sdb::Carconfig843(signal->value.int32Values[0]);
        }
        return sdb::Carconfig843(-1);
    }

    sdb::Carconfig844 IPCPSignalManager::getcarconfig844() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig844));
        }
        if (signal.has_value()){
            return sdb::Carconfig844(signal->value.int32Values[0]);
        }
        return sdb::Carconfig844(-1);
    }

    sdb::Carconfig845 IPCPSignalManager::getcarconfig845() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig845));
        }
        if (signal.has_value()){
            return sdb::Carconfig845(signal->value.int32Values[0]);
        }
        return sdb::Carconfig845(-1);
    }

    sdb::Carconfig846 IPCPSignalManager::getcarconfig846() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig846));
        }
        if (signal.has_value()){
            return sdb::Carconfig846(signal->value.int32Values[0]);
        }
        return sdb::Carconfig846(-1);
    }

    sdb::Carconfig847 IPCPSignalManager::getcarconfig847() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig847));
        }
        if (signal.has_value()){
            return sdb::Carconfig847(signal->value.int32Values[0]);
        }
        return sdb::Carconfig847(-1);
    }

    sdb::Carconfig848 IPCPSignalManager::getcarconfig848() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig848));
        }
        if (signal.has_value()){
            return sdb::Carconfig848(signal->value.int32Values[0]);
        }
        return sdb::Carconfig848(-1);
    }

    sdb::Carconfig849 IPCPSignalManager::getcarconfig849() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig849));
        }
        if (signal.has_value()){
            return sdb::Carconfig849(signal->value.int32Values[0]);
        }
        return sdb::Carconfig849(-1);
    }

    sdb::Carconfig850 IPCPSignalManager::getcarconfig850() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig850));
        }
        if (signal.has_value()){
            return sdb::Carconfig850(signal->value.int32Values[0]);
        }
        return sdb::Carconfig850(-1);
    }

    sdb::Carconfig851 IPCPSignalManager::getcarconfig851() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig851));
        }
        if (signal.has_value()){
            return sdb::Carconfig851(signal->value.int32Values[0]);
        }
        return sdb::Carconfig851(-1);
    }

    sdb::Carconfig852 IPCPSignalManager::getcarconfig852() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig852));
        }
        if (signal.has_value()){
            return sdb::Carconfig852(signal->value.int32Values[0]);
        }
        return sdb::Carconfig852(-1);
    }

    sdb::Carconfig853 IPCPSignalManager::getcarconfig853() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig853));
        }
        if (signal.has_value()){
            return sdb::Carconfig853(signal->value.int32Values[0]);
        }
        return sdb::Carconfig853(-1);
    }

    sdb::Carconfig854 IPCPSignalManager::getcarconfig854() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig854));
        }
        if (signal.has_value()){
            return sdb::Carconfig854(signal->value.int32Values[0]);
        }
        return sdb::Carconfig854(-1);
    }

    sdb::Carconfig855 IPCPSignalManager::getcarconfig855() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig855));
        }
        if (signal.has_value()){
            return sdb::Carconfig855(signal->value.int32Values[0]);
        }
        return sdb::Carconfig855(-1);
    }

    sdb::Carconfig856 IPCPSignalManager::getcarconfig856() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig856));
        }
        if (signal.has_value()){
            return sdb::Carconfig856(signal->value.int32Values[0]);
        }
        return sdb::Carconfig856(-1);
    }

    sdb::Carconfig857 IPCPSignalManager::getcarconfig857() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig857));
        }
        if (signal.has_value()){
            return sdb::Carconfig857(signal->value.int32Values[0]);
        }
        return sdb::Carconfig857(-1);
    }

    sdb::Carconfig858 IPCPSignalManager::getcarconfig858() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig858));
        }
        if (signal.has_value()){
            return sdb::Carconfig858(signal->value.int32Values[0]);
        }
        return sdb::Carconfig858(-1);
    }

    sdb::Carconfig859 IPCPSignalManager::getcarconfig859() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig859));
        }
        if (signal.has_value()){
            return sdb::Carconfig859(signal->value.int32Values[0]);
        }
        return sdb::Carconfig859(-1);
    }

    sdb::Carconfig860 IPCPSignalManager::getcarconfig860() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig860));
        }
        if (signal.has_value()){
            return sdb::Carconfig860(signal->value.int32Values[0]);
        }
        return sdb::Carconfig860(-1);
    }

    sdb::Carconfig861 IPCPSignalManager::getcarconfig861() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig861));
        }
        if (signal.has_value()){
            return sdb::Carconfig861(signal->value.int32Values[0]);
        }
        return sdb::Carconfig861(-1);
    }

    sdb::Carconfig862 IPCPSignalManager::getcarconfig862() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig862));
        }
        if (signal.has_value()){
            return sdb::Carconfig862(signal->value.int32Values[0]);
        }
        return sdb::Carconfig862(-1);
    }

    sdb::Carconfig863 IPCPSignalManager::getcarconfig863() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig863));
        }
        if (signal.has_value()){
            return sdb::Carconfig863(signal->value.int32Values[0]);
        }
        return sdb::Carconfig863(-1);
    }

    sdb::Carconfig864 IPCPSignalManager::getcarconfig864() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig864));
        }
        if (signal.has_value()){
            return sdb::Carconfig864(signal->value.int32Values[0]);
        }
        return sdb::Carconfig864(-1);
    }

    sdb::Carconfig865 IPCPSignalManager::getcarconfig865() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig865));
        }
        if (signal.has_value()){
            return sdb::Carconfig865(signal->value.int32Values[0]);
        }
        return sdb::Carconfig865(-1);
    }

    sdb::Carconfig866 IPCPSignalManager::getcarconfig866() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig866));
        }
        if (signal.has_value()){
            return sdb::Carconfig866(signal->value.int32Values[0]);
        }
        return sdb::Carconfig866(-1);
    }

    sdb::Carconfig867 IPCPSignalManager::getcarconfig867() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig867));
        }
        if (signal.has_value()){
            return sdb::Carconfig867(signal->value.int32Values[0]);
        }
        return sdb::Carconfig867(-1);
    }

    sdb::Carconfig868 IPCPSignalManager::getcarconfig868() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig868));
        }
        if (signal.has_value()){
            return sdb::Carconfig868(signal->value.int32Values[0]);
        }
        return sdb::Carconfig868(-1);
    }

    sdb::Carconfig869 IPCPSignalManager::getcarconfig869() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig869));
        }
        if (signal.has_value()){
            return sdb::Carconfig869(signal->value.int32Values[0]);
        }
        return sdb::Carconfig869(-1);
    }

    sdb::Carconfig870 IPCPSignalManager::getcarconfig870() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig870));
        }
        if (signal.has_value()){
            return sdb::Carconfig870(signal->value.int32Values[0]);
        }
        return sdb::Carconfig870(-1);
    }

    sdb::Carconfig871 IPCPSignalManager::getcarconfig871() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig871));
        }
        if (signal.has_value()){
            return sdb::Carconfig871(signal->value.int32Values[0]);
        }
        return sdb::Carconfig871(-1);
    }

    sdb::Carconfig872 IPCPSignalManager::getcarconfig872() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig872));
        }
        if (signal.has_value()){
            return sdb::Carconfig872(signal->value.int32Values[0]);
        }
        return sdb::Carconfig872(-1);
    }

    sdb::Carconfig873 IPCPSignalManager::getcarconfig873() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig873));
        }
        if (signal.has_value()){
            return sdb::Carconfig873(signal->value.int32Values[0]);
        }
        return sdb::Carconfig873(-1);
    }

    sdb::Carconfig874 IPCPSignalManager::getcarconfig874() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig874));
        }
        if (signal.has_value()){
            return sdb::Carconfig874(signal->value.int32Values[0]);
        }
        return sdb::Carconfig874(-1);
    }

    sdb::Carconfig875 IPCPSignalManager::getcarconfig875() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig875));
        }
        if (signal.has_value()){
            return sdb::Carconfig875(signal->value.int32Values[0]);
        }
        return sdb::Carconfig875(-1);
    }

    sdb::Carconfig876 IPCPSignalManager::getcarconfig876() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig876));
        }
        if (signal.has_value()){
            return sdb::Carconfig876(signal->value.int32Values[0]);
        }
        return sdb::Carconfig876(-1);
    }

    sdb::Carconfig877 IPCPSignalManager::getcarconfig877() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig877));
        }
        if (signal.has_value()){
            return sdb::Carconfig877(signal->value.int32Values[0]);
        }
        return sdb::Carconfig877(-1);
    }

    sdb::Carconfig878 IPCPSignalManager::getcarconfig878() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig878));
        }
        if (signal.has_value()){
            return sdb::Carconfig878(signal->value.int32Values[0]);
        }
        return sdb::Carconfig878(-1);
    }

    sdb::Carconfig879 IPCPSignalManager::getcarconfig879() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig879));
        }
        if (signal.has_value()){
            return sdb::Carconfig879(signal->value.int32Values[0]);
        }
        return sdb::Carconfig879(-1);
    }

    sdb::Carconfig880 IPCPSignalManager::getcarconfig880() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig880));
        }
        if (signal.has_value()){
            return sdb::Carconfig880(signal->value.int32Values[0]);
        }
        return sdb::Carconfig880(-1);
    }

    sdb::Carconfig881 IPCPSignalManager::getcarconfig881() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig881));
        }
        if (signal.has_value()){
            return sdb::Carconfig881(signal->value.int32Values[0]);
        }
        return sdb::Carconfig881(-1);
    }

    sdb::Carconfig882 IPCPSignalManager::getcarconfig882() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig882));
        }
        if (signal.has_value()){
            return sdb::Carconfig882(signal->value.int32Values[0]);
        }
        return sdb::Carconfig882(-1);
    }

    sdb::Carconfig883 IPCPSignalManager::getcarconfig883() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig883));
        }
        if (signal.has_value()){
            return sdb::Carconfig883(signal->value.int32Values[0]);
        }
        return sdb::Carconfig883(-1);
    }

    sdb::Carconfig884 IPCPSignalManager::getcarconfig884() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig884));
        }
        if (signal.has_value()){
            return sdb::Carconfig884(signal->value.int32Values[0]);
        }
        return sdb::Carconfig884(-1);
    }

    sdb::Carconfig885 IPCPSignalManager::getcarconfig885() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig885));
        }
        if (signal.has_value()){
            return sdb::Carconfig885(signal->value.int32Values[0]);
        }
        return sdb::Carconfig885(-1);
    }

    sdb::Carconfig886 IPCPSignalManager::getcarconfig886() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig886));
        }
        if (signal.has_value()){
            return sdb::Carconfig886(signal->value.int32Values[0]);
        }
        return sdb::Carconfig886(-1);
    }

    sdb::Carconfig887 IPCPSignalManager::getcarconfig887() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig887));
        }
        if (signal.has_value()){
            return sdb::Carconfig887(signal->value.int32Values[0]);
        }
        return sdb::Carconfig887(-1);
    }

    sdb::Carconfig888 IPCPSignalManager::getcarconfig888() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig888));
        }
        if (signal.has_value()){
            return sdb::Carconfig888(signal->value.int32Values[0]);
        }
        return sdb::Carconfig888(-1);
    }

    sdb::Carconfig889 IPCPSignalManager::getcarconfig889() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig889));
        }
        if (signal.has_value()){
            return sdb::Carconfig889(signal->value.int32Values[0]);
        }
        return sdb::Carconfig889(-1);
    }

    sdb::Carconfig890 IPCPSignalManager::getcarconfig890() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig890));
        }
        if (signal.has_value()){
            return sdb::Carconfig890(signal->value.int32Values[0]);
        }
        return sdb::Carconfig890(-1);
    }

    sdb::Carconfig891 IPCPSignalManager::getcarconfig891() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig891));
        }
        if (signal.has_value()){
            return sdb::Carconfig891(signal->value.int32Values[0]);
        }
        return sdb::Carconfig891(-1);
    }

    sdb::Carconfig892 IPCPSignalManager::getcarconfig892() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig892));
        }
        if (signal.has_value()){
            return sdb::Carconfig892(signal->value.int32Values[0]);
        }
        return sdb::Carconfig892(-1);
    }

    sdb::Carconfig893 IPCPSignalManager::getcarconfig893() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig893));
        }
        if (signal.has_value()){
            return sdb::Carconfig893(signal->value.int32Values[0]);
        }
        return sdb::Carconfig893(-1);
    }

    sdb::Carconfig894 IPCPSignalManager::getcarconfig894() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig894));
        }
        if (signal.has_value()){
            return sdb::Carconfig894(signal->value.int32Values[0]);
        }
        return sdb::Carconfig894(-1);
    }

    sdb::Carconfig895 IPCPSignalManager::getcarconfig895() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig895));
        }
        if (signal.has_value()){
            return sdb::Carconfig895(signal->value.int32Values[0]);
        }
        return sdb::Carconfig895(-1);
    }

    sdb::Carconfig896 IPCPSignalManager::getcarconfig896() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig896));
        }
        if (signal.has_value()){
            return sdb::Carconfig896(signal->value.int32Values[0]);
        }
        return sdb::Carconfig896(-1);
    }

    sdb::Carconfig897 IPCPSignalManager::getcarconfig897() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig897));
        }
        if (signal.has_value()){
            return sdb::Carconfig897(signal->value.int32Values[0]);
        }
        return sdb::Carconfig897(-1);
    }

    sdb::Carconfig898 IPCPSignalManager::getcarconfig898() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig898));
        }
        if (signal.has_value()){
            return sdb::Carconfig898(signal->value.int32Values[0]);
        }
        return sdb::Carconfig898(-1);
    }

    sdb::Carconfig899 IPCPSignalManager::getcarconfig899() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig899));
        }
        if (signal.has_value()){
            return sdb::Carconfig899(signal->value.int32Values[0]);
        }
        return sdb::Carconfig899(-1);
    }

    sdb::Carconfig900 IPCPSignalManager::getcarconfig900() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig900));
        }
        if (signal.has_value()){
            return sdb::Carconfig900(signal->value.int32Values[0]);
        }
        return sdb::Carconfig900(-1);
    }

    sdb::Carconfig901 IPCPSignalManager::getcarconfig901() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig901));
        }
        if (signal.has_value()){
            return sdb::Carconfig901(signal->value.int32Values[0]);
        }
        return sdb::Carconfig901(-1);
    }

    sdb::Carconfig902 IPCPSignalManager::getcarconfig902() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig902));
        }
        if (signal.has_value()){
            return sdb::Carconfig902(signal->value.int32Values[0]);
        }
        return sdb::Carconfig902(-1);
    }

    sdb::Carconfig903 IPCPSignalManager::getcarconfig903() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig903));
        }
        if (signal.has_value()){
            return sdb::Carconfig903(signal->value.int32Values[0]);
        }
        return sdb::Carconfig903(-1);
    }

    sdb::Carconfig904 IPCPSignalManager::getcarconfig904() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig904));
        }
        if (signal.has_value()){
            return sdb::Carconfig904(signal->value.int32Values[0]);
        }
        return sdb::Carconfig904(-1);
    }

    sdb::Carconfig905 IPCPSignalManager::getcarconfig905() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig905));
        }
        if (signal.has_value()){
            return sdb::Carconfig905(signal->value.int32Values[0]);
        }
        return sdb::Carconfig905(-1);
    }

    sdb::Carconfig906 IPCPSignalManager::getcarconfig906() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig906));
        }
        if (signal.has_value()){
            return sdb::Carconfig906(signal->value.int32Values[0]);
        }
        return sdb::Carconfig906(-1);
    }

    sdb::Carconfig907 IPCPSignalManager::getcarconfig907() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig907));
        }
        if (signal.has_value()){
            return sdb::Carconfig907(signal->value.int32Values[0]);
        }
        return sdb::Carconfig907(-1);
    }

    sdb::Carconfig908 IPCPSignalManager::getcarconfig908() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig908));
        }
        if (signal.has_value()){
            return sdb::Carconfig908(signal->value.int32Values[0]);
        }
        return sdb::Carconfig908(-1);
    }

    sdb::Carconfig909 IPCPSignalManager::getcarconfig909() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig909));
        }
        if (signal.has_value()){
            return sdb::Carconfig909(signal->value.int32Values[0]);
        }
        return sdb::Carconfig909(-1);
    }

    sdb::Carconfig910 IPCPSignalManager::getcarconfig910() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig910));
        }
        if (signal.has_value()){
            return sdb::Carconfig910(signal->value.int32Values[0]);
        }
        return sdb::Carconfig910(-1);
    }

    sdb::Carconfig911 IPCPSignalManager::getcarconfig911() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig911));
        }
        if (signal.has_value()){
            return sdb::Carconfig911(signal->value.int32Values[0]);
        }
        return sdb::Carconfig911(-1);
    }

    sdb::Carconfig912 IPCPSignalManager::getcarconfig912() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig912));
        }
        if (signal.has_value()){
            return sdb::Carconfig912(signal->value.int32Values[0]);
        }
        return sdb::Carconfig912(-1);
    }

    sdb::Carconfig913 IPCPSignalManager::getcarconfig913() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig913));
        }
        if (signal.has_value()){
            return sdb::Carconfig913(signal->value.int32Values[0]);
        }
        return sdb::Carconfig913(-1);
    }

    sdb::Carconfig914 IPCPSignalManager::getcarconfig914() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig914));
        }
        if (signal.has_value()){
            return sdb::Carconfig914(signal->value.int32Values[0]);
        }
        return sdb::Carconfig914(-1);
    }

    sdb::Carconfig915 IPCPSignalManager::getcarconfig915() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig915));
        }
        if (signal.has_value()){
            return sdb::Carconfig915(signal->value.int32Values[0]);
        }
        return sdb::Carconfig915(-1);
    }

    sdb::Carconfig916 IPCPSignalManager::getcarconfig916() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig916));
        }
        if (signal.has_value()){
            return sdb::Carconfig916(signal->value.int32Values[0]);
        }
        return sdb::Carconfig916(-1);
    }

    sdb::Carconfig917 IPCPSignalManager::getcarconfig917() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig917));
        }
        if (signal.has_value()){
            return sdb::Carconfig917(signal->value.int32Values[0]);
        }
        return sdb::Carconfig917(-1);
    }

    sdb::Carconfig918 IPCPSignalManager::getcarconfig918() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig918));
        }
        if (signal.has_value()){
            return sdb::Carconfig918(signal->value.int32Values[0]);
        }
        return sdb::Carconfig918(-1);
    }

    sdb::Carconfig919 IPCPSignalManager::getcarconfig919() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig919));
        }
        if (signal.has_value()){
            return sdb::Carconfig919(signal->value.int32Values[0]);
        }
        return sdb::Carconfig919(-1);
    }

    sdb::Carconfig920 IPCPSignalManager::getcarconfig920() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig920));
        }
        if (signal.has_value()){
            return sdb::Carconfig920(signal->value.int32Values[0]);
        }
        return sdb::Carconfig920(-1);
    }

    sdb::Carconfig921 IPCPSignalManager::getcarconfig921() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig921));
        }
        if (signal.has_value()){
            return sdb::Carconfig921(signal->value.int32Values[0]);
        }
        return sdb::Carconfig921(-1);
    }

    sdb::Carconfig922 IPCPSignalManager::getcarconfig922() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig922));
        }
        if (signal.has_value()){
            return sdb::Carconfig922(signal->value.int32Values[0]);
        }
        return sdb::Carconfig922(-1);
    }

    sdb::Carconfig923 IPCPSignalManager::getcarconfig923() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig923));
        }
        if (signal.has_value()){
            return sdb::Carconfig923(signal->value.int32Values[0]);
        }
        return sdb::Carconfig923(-1);
    }

    sdb::Carconfig924 IPCPSignalManager::getcarconfig924() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig924));
        }
        if (signal.has_value()){
            return sdb::Carconfig924(signal->value.int32Values[0]);
        }
        return sdb::Carconfig924(-1);
    }

    sdb::Carconfig925 IPCPSignalManager::getcarconfig925() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig925));
        }
        if (signal.has_value()){
            return sdb::Carconfig925(signal->value.int32Values[0]);
        }
        return sdb::Carconfig925(-1);
    }

    sdb::Carconfig926 IPCPSignalManager::getcarconfig926() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig926));
        }
        if (signal.has_value()){
            return sdb::Carconfig926(signal->value.int32Values[0]);
        }
        return sdb::Carconfig926(-1);
    }

    sdb::Carconfig927 IPCPSignalManager::getcarconfig927() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig927));
        }
        if (signal.has_value()){
            return sdb::Carconfig927(signal->value.int32Values[0]);
        }
        return sdb::Carconfig927(-1);
    }

    sdb::Carconfig928 IPCPSignalManager::getcarconfig928() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig928));
        }
        if (signal.has_value()){
            return sdb::Carconfig928(signal->value.int32Values[0]);
        }
        return sdb::Carconfig928(-1);
    }

    sdb::Carconfig929 IPCPSignalManager::getcarconfig929() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig929));
        }
        if (signal.has_value()){
            return sdb::Carconfig929(signal->value.int32Values[0]);
        }
        return sdb::Carconfig929(-1);
    }

    sdb::Carconfig930 IPCPSignalManager::getcarconfig930() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig930));
        }
        if (signal.has_value()){
            return sdb::Carconfig930(signal->value.int32Values[0]);
        }
        return sdb::Carconfig930(-1);
    }

    sdb::Carconfig931 IPCPSignalManager::getcarconfig931() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig931));
        }
        if (signal.has_value()){
            return sdb::Carconfig931(signal->value.int32Values[0]);
        }
        return sdb::Carconfig931(-1);
    }

    sdb::Carconfig932 IPCPSignalManager::getcarconfig932() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig932));
        }
        if (signal.has_value()){
            return sdb::Carconfig932(signal->value.int32Values[0]);
        }
        return sdb::Carconfig932(-1);
    }

    sdb::Carconfig933 IPCPSignalManager::getcarconfig933() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig933));
        }
        if (signal.has_value()){
            return sdb::Carconfig933(signal->value.int32Values[0]);
        }
        return sdb::Carconfig933(-1);
    }

    sdb::Carconfig934 IPCPSignalManager::getcarconfig934() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig934));
        }
        if (signal.has_value()){
            return sdb::Carconfig934(signal->value.int32Values[0]);
        }
        return sdb::Carconfig934(-1);
    }

    sdb::Carconfig935 IPCPSignalManager::getcarconfig935() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig935));
        }
        if (signal.has_value()){
            return sdb::Carconfig935(signal->value.int32Values[0]);
        }
        return sdb::Carconfig935(-1);
    }

    sdb::Carconfig936 IPCPSignalManager::getcarconfig936() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig936));
        }
        if (signal.has_value()){
            return sdb::Carconfig936(signal->value.int32Values[0]);
        }
        return sdb::Carconfig936(-1);
    }

    sdb::Carconfig937 IPCPSignalManager::getcarconfig937() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig937));
        }
        if (signal.has_value()){
            return sdb::Carconfig937(signal->value.int32Values[0]);
        }
        return sdb::Carconfig937(-1);
    }

    sdb::Carconfig938 IPCPSignalManager::getcarconfig938() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig938));
        }
        if (signal.has_value()){
            return sdb::Carconfig938(signal->value.int32Values[0]);
        }
        return sdb::Carconfig938(-1);
    }

    sdb::Carconfig939 IPCPSignalManager::getcarconfig939() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig939));
        }
        if (signal.has_value()){
            return sdb::Carconfig939(signal->value.int32Values[0]);
        }
        return sdb::Carconfig939(-1);
    }

    sdb::Carconfig940 IPCPSignalManager::getcarconfig940() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig940));
        }
        if (signal.has_value()){
            return sdb::Carconfig940(signal->value.int32Values[0]);
        }
        return sdb::Carconfig940(-1);
    }

    sdb::Carconfig941 IPCPSignalManager::getcarconfig941() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig941));
        }
        if (signal.has_value()){
            return sdb::Carconfig941(signal->value.int32Values[0]);
        }
        return sdb::Carconfig941(-1);
    }

    sdb::Carconfig942 IPCPSignalManager::getcarconfig942() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig942));
        }
        if (signal.has_value()){
            return sdb::Carconfig942(signal->value.int32Values[0]);
        }
        return sdb::Carconfig942(-1);
    }

    sdb::Carconfig943 IPCPSignalManager::getcarconfig943() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig943));
        }
        if (signal.has_value()){
            return sdb::Carconfig943(signal->value.int32Values[0]);
        }
        return sdb::Carconfig943(-1);
    }

    sdb::Carconfig944 IPCPSignalManager::getcarconfig944() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig944));
        }
        if (signal.has_value()){
            return sdb::Carconfig944(signal->value.int32Values[0]);
        }
        return sdb::Carconfig944(-1);
    }

    sdb::Carconfig945 IPCPSignalManager::getcarconfig945() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig945));
        }
        if (signal.has_value()){
            return sdb::Carconfig945(signal->value.int32Values[0]);
        }
        return sdb::Carconfig945(-1);
    }

    sdb::Carconfig946 IPCPSignalManager::getcarconfig946() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig946));
        }
        if (signal.has_value()){
            return sdb::Carconfig946(signal->value.int32Values[0]);
        }
        return sdb::Carconfig946(-1);
    }

    sdb::Carconfig947 IPCPSignalManager::getcarconfig947() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig947));
        }
        if (signal.has_value()){
            return sdb::Carconfig947(signal->value.int32Values[0]);
        }
        return sdb::Carconfig947(-1);
    }

    sdb::Carconfig948 IPCPSignalManager::getcarconfig948() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig948));
        }
        if (signal.has_value()){
            return sdb::Carconfig948(signal->value.int32Values[0]);
        }
        return sdb::Carconfig948(-1);
    }

    sdb::Carconfig949 IPCPSignalManager::getcarconfig949() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig949));
        }
        if (signal.has_value()){
            return sdb::Carconfig949(signal->value.int32Values[0]);
        }
        return sdb::Carconfig949(-1);
    }

    sdb::Carconfig950 IPCPSignalManager::getcarconfig950() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig950));
        }
        if (signal.has_value()){
            return sdb::Carconfig950(signal->value.int32Values[0]);
        }
        return sdb::Carconfig950(-1);
    }

    sdb::Carconfig951 IPCPSignalManager::getcarconfig951() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig951));
        }
        if (signal.has_value()){
            return sdb::Carconfig951(signal->value.int32Values[0]);
        }
        return sdb::Carconfig951(-1);
    }

    sdb::Carconfig952 IPCPSignalManager::getcarconfig952() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig952));
        }
        if (signal.has_value()){
            return sdb::Carconfig952(signal->value.int32Values[0]);
        }
        return sdb::Carconfig952(-1);
    }

    sdb::Carconfig953 IPCPSignalManager::getcarconfig953() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig953));
        }
        if (signal.has_value()){
            return sdb::Carconfig953(signal->value.int32Values[0]);
        }
        return sdb::Carconfig953(-1);
    }

    sdb::Carconfig954 IPCPSignalManager::getcarconfig954() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig954));
        }
        if (signal.has_value()){
            return sdb::Carconfig954(signal->value.int32Values[0]);
        }
        return sdb::Carconfig954(-1);
    }

    sdb::Carconfig955 IPCPSignalManager::getcarconfig955() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig955));
        }
        if (signal.has_value()){
            return sdb::Carconfig955(signal->value.int32Values[0]);
        }
        return sdb::Carconfig955(-1);
    }

    sdb::Carconfig956 IPCPSignalManager::getcarconfig956() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig956));
        }
        if (signal.has_value()){
            return sdb::Carconfig956(signal->value.int32Values[0]);
        }
        return sdb::Carconfig956(-1);
    }

    sdb::Carconfig957 IPCPSignalManager::getcarconfig957() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig957));
        }
        if (signal.has_value()){
            return sdb::Carconfig957(signal->value.int32Values[0]);
        }
        return sdb::Carconfig957(-1);
    }

    sdb::Carconfig958 IPCPSignalManager::getcarconfig958() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig958));
        }
        if (signal.has_value()){
            return sdb::Carconfig958(signal->value.int32Values[0]);
        }
        return sdb::Carconfig958(-1);
    }

    sdb::Carconfig959 IPCPSignalManager::getcarconfig959() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig959));
        }
        if (signal.has_value()){
            return sdb::Carconfig959(signal->value.int32Values[0]);
        }
        return sdb::Carconfig959(-1);
    }

    sdb::Carconfig960 IPCPSignalManager::getcarconfig960() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig960));
        }
        if (signal.has_value()){
            return sdb::Carconfig960(signal->value.int32Values[0]);
        }
        return sdb::Carconfig960(-1);
    }

    sdb::Carconfig961 IPCPSignalManager::getcarconfig961() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig961));
        }
        if (signal.has_value()){
            return sdb::Carconfig961(signal->value.int32Values[0]);
        }
        return sdb::Carconfig961(-1);
    }

    sdb::Carconfig962 IPCPSignalManager::getcarconfig962() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig962));
        }
        if (signal.has_value()){
            return sdb::Carconfig962(signal->value.int32Values[0]);
        }
        return sdb::Carconfig962(-1);
    }

    sdb::Carconfig963 IPCPSignalManager::getcarconfig963() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig963));
        }
        if (signal.has_value()){
            return sdb::Carconfig963(signal->value.int32Values[0]);
        }
        return sdb::Carconfig963(-1);
    }

    sdb::Carconfig964 IPCPSignalManager::getcarconfig964() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig964));
        }
        if (signal.has_value()){
            return sdb::Carconfig964(signal->value.int32Values[0]);
        }
        return sdb::Carconfig964(-1);
    }

    sdb::Carconfig965 IPCPSignalManager::getcarconfig965() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig965));
        }
        if (signal.has_value()){
            return sdb::Carconfig965(signal->value.int32Values[0]);
        }
        return sdb::Carconfig965(-1);
    }

    sdb::Carconfig966 IPCPSignalManager::getcarconfig966() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig966));
        }
        if (signal.has_value()){
            return sdb::Carconfig966(signal->value.int32Values[0]);
        }
        return sdb::Carconfig966(-1);
    }

    sdb::Carconfig967 IPCPSignalManager::getcarconfig967() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig967));
        }
        if (signal.has_value()){
            return sdb::Carconfig967(signal->value.int32Values[0]);
        }
        return sdb::Carconfig967(-1);
    }

    sdb::Carconfig968 IPCPSignalManager::getcarconfig968() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig968));
        }
        if (signal.has_value()){
            return sdb::Carconfig968(signal->value.int32Values[0]);
        }
        return sdb::Carconfig968(-1);
    }

    sdb::Carconfig969 IPCPSignalManager::getcarconfig969() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig969));
        }
        if (signal.has_value()){
            return sdb::Carconfig969(signal->value.int32Values[0]);
        }
        return sdb::Carconfig969(-1);
    }

    sdb::Carconfig970 IPCPSignalManager::getcarconfig970() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig970));
        }
        if (signal.has_value()){
            return sdb::Carconfig970(signal->value.int32Values[0]);
        }
        return sdb::Carconfig970(-1);
    }

    sdb::Carconfig971 IPCPSignalManager::getcarconfig971() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig971));
        }
        if (signal.has_value()){
            return sdb::Carconfig971(signal->value.int32Values[0]);
        }
        return sdb::Carconfig971(-1);
    }

    sdb::Carconfig972 IPCPSignalManager::getcarconfig972() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig972));
        }
        if (signal.has_value()){
            return sdb::Carconfig972(signal->value.int32Values[0]);
        }
        return sdb::Carconfig972(-1);
    }

    sdb::Carconfig973 IPCPSignalManager::getcarconfig973() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig973));
        }
        if (signal.has_value()){
            return sdb::Carconfig973(signal->value.int32Values[0]);
        }
        return sdb::Carconfig973(-1);
    }

    sdb::Carconfig974 IPCPSignalManager::getcarconfig974() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig974));
        }
        if (signal.has_value()){
            return sdb::Carconfig974(signal->value.int32Values[0]);
        }
        return sdb::Carconfig974(-1);
    }

    sdb::Carconfig975 IPCPSignalManager::getcarconfig975() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig975));
        }
        if (signal.has_value()){
            return sdb::Carconfig975(signal->value.int32Values[0]);
        }
        return sdb::Carconfig975(-1);
    }

    sdb::Carconfig976 IPCPSignalManager::getcarconfig976() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig976));
        }
        if (signal.has_value()){
            return sdb::Carconfig976(signal->value.int32Values[0]);
        }
        return sdb::Carconfig976(-1);
    }

    sdb::Carconfig977 IPCPSignalManager::getcarconfig977() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig977));
        }
        if (signal.has_value()){
            return sdb::Carconfig977(signal->value.int32Values[0]);
        }
        return sdb::Carconfig977(-1);
    }

    sdb::Carconfig978 IPCPSignalManager::getcarconfig978() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig978));
        }
        if (signal.has_value()){
            return sdb::Carconfig978(signal->value.int32Values[0]);
        }
        return sdb::Carconfig978(-1);
    }

    sdb::Carconfig979 IPCPSignalManager::getcarconfig979() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig979));
        }
        if (signal.has_value()){
            return sdb::Carconfig979(signal->value.int32Values[0]);
        }
        return sdb::Carconfig979(-1);
    }

    sdb::Carconfig980 IPCPSignalManager::getcarconfig980() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig980));
        }
        if (signal.has_value()){
            return sdb::Carconfig980(signal->value.int32Values[0]);
        }
        return sdb::Carconfig980(-1);
    }

    sdb::Carconfig981 IPCPSignalManager::getcarconfig981() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig981));
        }
        if (signal.has_value()){
            return sdb::Carconfig981(signal->value.int32Values[0]);
        }
        return sdb::Carconfig981(-1);
    }

    sdb::Carconfig982 IPCPSignalManager::getcarconfig982() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig982));
        }
        if (signal.has_value()){
            return sdb::Carconfig982(signal->value.int32Values[0]);
        }
        return sdb::Carconfig982(-1);
    }

    sdb::Carconfig983 IPCPSignalManager::getcarconfig983() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig983));
        }
        if (signal.has_value()){
            return sdb::Carconfig983(signal->value.int32Values[0]);
        }
        return sdb::Carconfig983(-1);
    }

    sdb::Carconfig984 IPCPSignalManager::getcarconfig984() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig984));
        }
        if (signal.has_value()){
            return sdb::Carconfig984(signal->value.int32Values[0]);
        }
        return sdb::Carconfig984(-1);
    }

    sdb::Carconfig985 IPCPSignalManager::getcarconfig985() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig985));
        }
        if (signal.has_value()){
            return sdb::Carconfig985(signal->value.int32Values[0]);
        }
        return sdb::Carconfig985(-1);
    }

    sdb::Carconfig986 IPCPSignalManager::getcarconfig986() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig986));
        }
        if (signal.has_value()){
            return sdb::Carconfig986(signal->value.int32Values[0]);
        }
        return sdb::Carconfig986(-1);
    }

    sdb::Carconfig987 IPCPSignalManager::getcarconfig987() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig987));
        }
        if (signal.has_value()){
            return sdb::Carconfig987(signal->value.int32Values[0]);
        }
        return sdb::Carconfig987(-1);
    }

    sdb::Carconfig988 IPCPSignalManager::getcarconfig988() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig988));
        }
        if (signal.has_value()){
            return sdb::Carconfig988(signal->value.int32Values[0]);
        }
        return sdb::Carconfig988(-1);
    }

    sdb::Carconfig989 IPCPSignalManager::getcarconfig989() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig989));
        }
        if (signal.has_value()){
            return sdb::Carconfig989(signal->value.int32Values[0]);
        }
        return sdb::Carconfig989(-1);
    }

    sdb::Carconfig990 IPCPSignalManager::getcarconfig990() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig990));
        }
        if (signal.has_value()){
            return sdb::Carconfig990(signal->value.int32Values[0]);
        }
        return sdb::Carconfig990(-1);
    }

    sdb::Carconfig991 IPCPSignalManager::getcarconfig991() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig991));
        }
        if (signal.has_value()){
            return sdb::Carconfig991(signal->value.int32Values[0]);
        }
        return sdb::Carconfig991(-1);
    }

    sdb::Carconfig992 IPCPSignalManager::getcarconfig992() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig992));
        }
        if (signal.has_value()){
            return sdb::Carconfig992(signal->value.int32Values[0]);
        }
        return sdb::Carconfig992(-1);
    }

    sdb::Carconfig993 IPCPSignalManager::getcarconfig993() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig993));
        }
        if (signal.has_value()){
            return sdb::Carconfig993(signal->value.int32Values[0]);
        }
        return sdb::Carconfig993(-1);
    }

    sdb::Carconfig994 IPCPSignalManager::getcarconfig994() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig994));
        }
        if (signal.has_value()){
            return sdb::Carconfig994(signal->value.int32Values[0]);
        }
        return sdb::Carconfig994(-1);
    }

    sdb::Carconfig995 IPCPSignalManager::getcarconfig995() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig995));
        }
        if (signal.has_value()){
            return sdb::Carconfig995(signal->value.int32Values[0]);
        }
        return sdb::Carconfig995(-1);
    }

    sdb::Carconfig996 IPCPSignalManager::getcarconfig996() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig996));
        }
        if (signal.has_value()){
            return sdb::Carconfig996(signal->value.int32Values[0]);
        }
        return sdb::Carconfig996(-1);
    }

    sdb::Carconfig997 IPCPSignalManager::getcarconfig997() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig997));
        }
        if (signal.has_value()){
            return sdb::Carconfig997(signal->value.int32Values[0]);
        }
        return sdb::Carconfig997(-1);
    }

    sdb::Carconfig998 IPCPSignalManager::getcarconfig998() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig998));
        }
        if (signal.has_value()){
            return sdb::Carconfig998(signal->value.int32Values[0]);
        }
        return sdb::Carconfig998(-1);
    }

    sdb::Carconfig999 IPCPSignalManager::getcarconfig999() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig999));
        }
        if (signal.has_value()){
            return sdb::Carconfig999(signal->value.int32Values[0]);
        }
        return sdb::Carconfig999(-1);
    }

    sdb::CarConfig1000 IPCPSignalManager::getcarconfig1000() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1000));
        }
        if (signal.has_value()){
            return sdb::CarConfig1000(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1000(-1);
    }

    sdb::CarConfig1001 IPCPSignalManager::getcarconfig1001() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1001));
        }
        if (signal.has_value()){
            return sdb::CarConfig1001(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1001(-1);
    }

    sdb::CarConfig1002 IPCPSignalManager::getcarconfig1002() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1002));
        }
        if (signal.has_value()){
            return sdb::CarConfig1002(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1002(-1);
    }

    sdb::CarConfig1003 IPCPSignalManager::getcarconfig1003() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1003));
        }
        if (signal.has_value()){
            return sdb::CarConfig1003(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1003(-1);
    }

    sdb::CarConfig1004 IPCPSignalManager::getcarconfig1004() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1004));
        }
        if (signal.has_value()){
            return sdb::CarConfig1004(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1004(-1);
    }

    sdb::CarConfig1005 IPCPSignalManager::getcarconfig1005() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1005));
        }
        if (signal.has_value()){
            return sdb::CarConfig1005(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1005(-1);
    }

    sdb::CarConfig1006 IPCPSignalManager::getcarconfig1006() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1006));
        }
        if (signal.has_value()){
            return sdb::CarConfig1006(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1006(-1);
    }

    sdb::CarConfig1007 IPCPSignalManager::getcarconfig1007() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1007));
        }
        if (signal.has_value()){
            return sdb::CarConfig1007(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1007(-1);
    }

    sdb::CarConfig1008 IPCPSignalManager::getcarconfig1008() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1008));
        }
        if (signal.has_value()){
            return sdb::CarConfig1008(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1008(-1);
    }

    sdb::CarConfig1009 IPCPSignalManager::getcarconfig1009() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1009));
        }
        if (signal.has_value()){
            return sdb::CarConfig1009(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1009(-1);
    }

    sdb::CarConfig1010 IPCPSignalManager::getcarconfig1010() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1010));
        }
        if (signal.has_value()){
            return sdb::CarConfig1010(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1010(-1);
    }

    sdb::CarConfig1011 IPCPSignalManager::getcarconfig1011() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1011));
        }
        if (signal.has_value()){
            return sdb::CarConfig1011(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1011(-1);
    }

    sdb::CarConfig1012 IPCPSignalManager::getcarconfig1012() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1012));
        }
        if (signal.has_value()){
            return sdb::CarConfig1012(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1012(-1);
    }

    sdb::CarConfig1013 IPCPSignalManager::getcarconfig1013() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1013));
        }
        if (signal.has_value()){
            return sdb::CarConfig1013(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1013(-1);
    }

    sdb::CarConfig1014 IPCPSignalManager::getcarconfig1014() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1014));
        }
        if (signal.has_value()){
            return sdb::CarConfig1014(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1014(-1);
    }

    sdb::CarConfig1015 IPCPSignalManager::getcarconfig1015() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1015));
        }
        if (signal.has_value()){
            return sdb::CarConfig1015(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1015(-1);
    }

    sdb::CarConfig1016 IPCPSignalManager::getcarconfig1016() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1016));
        }
        if (signal.has_value()){
            return sdb::CarConfig1016(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1016(-1);
    }

    sdb::CarConfig1017 IPCPSignalManager::getcarconfig1017() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1017));
        }
        if (signal.has_value()){
            return sdb::CarConfig1017(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1017(-1);
    }

    sdb::CarConfig1018 IPCPSignalManager::getcarconfig1018() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1018));
        }
        if (signal.has_value()){
            return sdb::CarConfig1018(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1018(-1);
    }

    sdb::CarConfig1019 IPCPSignalManager::getcarconfig1019() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1019));
        }
        if (signal.has_value()){
            return sdb::CarConfig1019(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1019(-1);
    }

    sdb::CarConfig1020 IPCPSignalManager::getcarconfig1020() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1020));
        }
        if (signal.has_value()){
            return sdb::CarConfig1020(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1020(-1);
    }

    sdb::CarConfig1021 IPCPSignalManager::getcarconfig1021() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1021));
        }
        if (signal.has_value()){
            return sdb::CarConfig1021(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1021(-1);
    }

    sdb::CarConfig1022 IPCPSignalManager::getcarconfig1022() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1022));
        }
        if (signal.has_value()){
            return sdb::CarConfig1022(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1022(-1);
    }

    sdb::CarConfig1023 IPCPSignalManager::getcarconfig1023() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1023));
        }
        if (signal.has_value()){
            return sdb::CarConfig1023(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1023(-1);
    }

    sdb::CarConfig1024 IPCPSignalManager::getcarconfig1024() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1024));
        }
        if (signal.has_value()){
            return sdb::CarConfig1024(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1024(-1);
    }

    sdb::CarConfig1025 IPCPSignalManager::getcarconfig1025() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1025));
        }
        if (signal.has_value()){
            return sdb::CarConfig1025(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1025(-1);
    }

    sdb::CarConfig1026 IPCPSignalManager::getcarconfig1026() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1026));
        }
        if (signal.has_value()){
            return sdb::CarConfig1026(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1026(-1);
    }

    sdb::CarConfig1027 IPCPSignalManager::getcarconfig1027() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1027));
        }
        if (signal.has_value()){
            return sdb::CarConfig1027(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1027(-1);
    }

    sdb::CarConfig1028 IPCPSignalManager::getcarconfig1028() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1028));
        }
        if (signal.has_value()){
            return sdb::CarConfig1028(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1028(-1);
    }

    sdb::CarConfig1029 IPCPSignalManager::getcarconfig1029() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1029));
        }
        if (signal.has_value()){
            return sdb::CarConfig1029(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1029(-1);
    }

    sdb::CarConfig1030 IPCPSignalManager::getcarconfig1030() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1030));
        }
        if (signal.has_value()){
            return sdb::CarConfig1030(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1030(-1);
    }

    sdb::CarConfig1031 IPCPSignalManager::getcarconfig1031() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1031));
        }
        if (signal.has_value()){
            return sdb::CarConfig1031(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1031(-1);
    }

    sdb::CarConfig1032 IPCPSignalManager::getcarconfig1032() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1032));
        }
        if (signal.has_value()){
            return sdb::CarConfig1032(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1032(-1);
    }

    sdb::CarConfig1033 IPCPSignalManager::getcarconfig1033() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1033));
        }
        if (signal.has_value()){
            return sdb::CarConfig1033(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1033(-1);
    }

    sdb::CarConfig1034 IPCPSignalManager::getcarconfig1034() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1034));
        }
        if (signal.has_value()){
            return sdb::CarConfig1034(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1034(-1);
    }

    sdb::CarConfig1035 IPCPSignalManager::getcarconfig1035() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1035));
        }
        if (signal.has_value()){
            return sdb::CarConfig1035(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1035(-1);
    }

    sdb::CarConfig1036 IPCPSignalManager::getcarconfig1036() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1036));
        }
        if (signal.has_value()){
            return sdb::CarConfig1036(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1036(-1);
    }

    sdb::CarConfig1037 IPCPSignalManager::getcarconfig1037() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1037));
        }
        if (signal.has_value()){
            return sdb::CarConfig1037(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1037(-1);
    }

    sdb::CarConfig1038 IPCPSignalManager::getcarconfig1038() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1038));
        }
        if (signal.has_value()){
            return sdb::CarConfig1038(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1038(-1);
    }

    sdb::CarConfig1039 IPCPSignalManager::getcarconfig1039() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1039));
        }
        if (signal.has_value()){
            return sdb::CarConfig1039(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1039(-1);
    }

    sdb::CarConfig1040 IPCPSignalManager::getcarconfig1040() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1040));
        }
        if (signal.has_value()){
            return sdb::CarConfig1040(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1040(-1);
    }

    sdb::CarConfig1041 IPCPSignalManager::getcarconfig1041() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1041));
        }
        if (signal.has_value()){
            return sdb::CarConfig1041(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1041(-1);
    }

    sdb::CarConfig1042 IPCPSignalManager::getcarconfig1042() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1042));
        }
        if (signal.has_value()){
            return sdb::CarConfig1042(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1042(-1);
    }

    sdb::CarConfig1043 IPCPSignalManager::getcarconfig1043() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1043));
        }
        if (signal.has_value()){
            return sdb::CarConfig1043(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1043(-1);
    }

    sdb::CarConfig1044 IPCPSignalManager::getcarconfig1044() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1044));
        }
        if (signal.has_value()){
            return sdb::CarConfig1044(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1044(-1);
    }

    sdb::CarConfig1045 IPCPSignalManager::getcarconfig1045() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1045));
        }
        if (signal.has_value()){
            return sdb::CarConfig1045(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1045(-1);
    }

    sdb::CarConfig1046 IPCPSignalManager::getcarconfig1046() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1046));
        }
        if (signal.has_value()){
            return sdb::CarConfig1046(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1046(-1);
    }

    sdb::CarConfig1047 IPCPSignalManager::getcarconfig1047() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1047));
        }
        if (signal.has_value()){
            return sdb::CarConfig1047(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1047(-1);
    }

    sdb::CarConfig1048 IPCPSignalManager::getcarconfig1048() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1048));
        }
        if (signal.has_value()){
            return sdb::CarConfig1048(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1048(-1);
    }

    sdb::CarConfig1049 IPCPSignalManager::getcarconfig1049() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1049));
        }
        if (signal.has_value()){
            return sdb::CarConfig1049(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1049(-1);
    }

    sdb::CarConfig1050 IPCPSignalManager::getcarconfig1050() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1050));
        }
        if (signal.has_value()){
            return sdb::CarConfig1050(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1050(-1);
    }

    sdb::CarConfig1051 IPCPSignalManager::getcarconfig1051() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1051));
        }
        if (signal.has_value()){
            return sdb::CarConfig1051(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1051(-1);
    }

    sdb::CarConfig1052 IPCPSignalManager::getcarconfig1052() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1052));
        }
        if (signal.has_value()){
            return sdb::CarConfig1052(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1052(-1);
    }

    sdb::CarConfig1053 IPCPSignalManager::getcarconfig1053() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1053));
        }
        if (signal.has_value()){
            return sdb::CarConfig1053(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1053(-1);
    }

    sdb::CarConfig1054 IPCPSignalManager::getcarconfig1054() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1054));
        }
        if (signal.has_value()){
            return sdb::CarConfig1054(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1054(-1);
    }

    sdb::CarConfig1055 IPCPSignalManager::getcarconfig1055() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1055));
        }
        if (signal.has_value()){
            return sdb::CarConfig1055(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1055(-1);
    }

    sdb::CarConfig1056 IPCPSignalManager::getcarconfig1056() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1056));
        }
        if (signal.has_value()){
            return sdb::CarConfig1056(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1056(-1);
    }

    sdb::CarConfig1057 IPCPSignalManager::getcarconfig1057() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1057));
        }
        if (signal.has_value()){
            return sdb::CarConfig1057(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1057(-1);
    }

    sdb::CarConfig1058 IPCPSignalManager::getcarconfig1058() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1058));
        }
        if (signal.has_value()){
            return sdb::CarConfig1058(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1058(-1);
    }

    sdb::CarConfig1059 IPCPSignalManager::getcarconfig1059() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1059));
        }
        if (signal.has_value()){
            return sdb::CarConfig1059(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1059(-1);
    }

    sdb::CarConfig1060 IPCPSignalManager::getcarconfig1060() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1060));
        }
        if (signal.has_value()){
            return sdb::CarConfig1060(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1060(-1);
    }

    sdb::CarConfig1061 IPCPSignalManager::getcarconfig1061() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1061));
        }
        if (signal.has_value()){
            return sdb::CarConfig1061(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1061(-1);
    }

    sdb::CarConfig1062 IPCPSignalManager::getcarconfig1062() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1062));
        }
        if (signal.has_value()){
            return sdb::CarConfig1062(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1062(-1);
    }

    sdb::CarConfig1063 IPCPSignalManager::getcarconfig1063() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1063));
        }
        if (signal.has_value()){
            return sdb::CarConfig1063(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1063(-1);
    }

    sdb::CarConfig1064 IPCPSignalManager::getcarconfig1064() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1064));
        }
        if (signal.has_value()){
            return sdb::CarConfig1064(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1064(-1);
    }

    sdb::CarConfig1065 IPCPSignalManager::getcarconfig1065() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1065));
        }
        if (signal.has_value()){
            return sdb::CarConfig1065(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1065(-1);
    }

    sdb::CarConfig1066 IPCPSignalManager::getcarconfig1066() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1066));
        }
        if (signal.has_value()){
            return sdb::CarConfig1066(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1066(-1);
    }

    sdb::CarConfig1067 IPCPSignalManager::getcarconfig1067() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1067));
        }
        if (signal.has_value()){
            return sdb::CarConfig1067(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1067(-1);
    }

    sdb::CarConfig1068 IPCPSignalManager::getcarconfig1068() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1068));
        }
        if (signal.has_value()){
            return sdb::CarConfig1068(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1068(-1);
    }

    sdb::CarConfig1069 IPCPSignalManager::getcarconfig1069() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1069));
        }
        if (signal.has_value()){
            return sdb::CarConfig1069(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1069(-1);
    }

    sdb::CarConfig1070 IPCPSignalManager::getcarconfig1070() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1070));
        }
        if (signal.has_value()){
            return sdb::CarConfig1070(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1070(-1);
    }

    sdb::CarConfig1071 IPCPSignalManager::getcarconfig1071() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1071));
        }
        if (signal.has_value()){
            return sdb::CarConfig1071(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1071(-1);
    }

    sdb::CarConfig1072 IPCPSignalManager::getcarconfig1072() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1072));
        }
        if (signal.has_value()){
            return sdb::CarConfig1072(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1072(-1);
    }

    sdb::CarConfig1073 IPCPSignalManager::getcarconfig1073() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1073));
        }
        if (signal.has_value()){
            return sdb::CarConfig1073(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1073(-1);
    }

    sdb::CarConfig1074 IPCPSignalManager::getcarconfig1074() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1074));
        }
        if (signal.has_value()){
            return sdb::CarConfig1074(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1074(-1);
    }

    sdb::CarConfig1075 IPCPSignalManager::getcarconfig1075() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1075));
        }
        if (signal.has_value()){
            return sdb::CarConfig1075(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1075(-1);
    }

    sdb::CarConfig1076 IPCPSignalManager::getcarconfig1076() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1076));
        }
        if (signal.has_value()){
            return sdb::CarConfig1076(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1076(-1);
    }

    sdb::CarConfig1077 IPCPSignalManager::getcarconfig1077() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1077));
        }
        if (signal.has_value()){
            return sdb::CarConfig1077(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1077(-1);
    }

    sdb::CarConfig1078 IPCPSignalManager::getcarconfig1078() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1078));
        }
        if (signal.has_value()){
            return sdb::CarConfig1078(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1078(-1);
    }

    sdb::CarConfig1079 IPCPSignalManager::getcarconfig1079() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1079));
        }
        if (signal.has_value()){
            return sdb::CarConfig1079(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1079(-1);
    }

    sdb::CarConfig1080 IPCPSignalManager::getcarconfig1080() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1080));
        }
        if (signal.has_value()){
            return sdb::CarConfig1080(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1080(-1);
    }

    sdb::CarConfig1081 IPCPSignalManager::getcarconfig1081() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1081));
        }
        if (signal.has_value()){
            return sdb::CarConfig1081(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1081(-1);
    }

    sdb::CarConfig1082 IPCPSignalManager::getcarconfig1082() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1082));
        }
        if (signal.has_value()){
            return sdb::CarConfig1082(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1082(-1);
    }

    sdb::CarConfig1083 IPCPSignalManager::getcarconfig1083() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1083));
        }
        if (signal.has_value()){
            return sdb::CarConfig1083(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1083(-1);
    }

    sdb::CarConfig1084 IPCPSignalManager::getcarconfig1084() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1084));
        }
        if (signal.has_value()){
            return sdb::CarConfig1084(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1084(-1);
    }

    sdb::CarConfig1085 IPCPSignalManager::getcarconfig1085() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1085));
        }
        if (signal.has_value()){
            return sdb::CarConfig1085(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1085(-1);
    }

    sdb::CarConfig1086 IPCPSignalManager::getcarconfig1086() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1086));
        }
        if (signal.has_value()){
            return sdb::CarConfig1086(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1086(-1);
    }

    sdb::CarConfig1087 IPCPSignalManager::getcarconfig1087() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1087));
        }
        if (signal.has_value()){
            return sdb::CarConfig1087(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1087(-1);
    }

    sdb::CarConfig1088 IPCPSignalManager::getcarconfig1088() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1088));
        }
        if (signal.has_value()){
            return sdb::CarConfig1088(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1088(-1);
    }

    sdb::CarConfig1089 IPCPSignalManager::getcarconfig1089() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1089));
        }
        if (signal.has_value()){
            return sdb::CarConfig1089(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1089(-1);
    }

    sdb::CarConfig1090 IPCPSignalManager::getcarconfig1090() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1090));
        }
        if (signal.has_value()){
            return sdb::CarConfig1090(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1090(-1);
    }

    sdb::CarConfig1091 IPCPSignalManager::getcarconfig1091() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1091));
        }
        if (signal.has_value()){
            return sdb::CarConfig1091(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1091(-1);
    }

    sdb::CarConfig1092 IPCPSignalManager::getcarconfig1092() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1092));
        }
        if (signal.has_value()){
            return sdb::CarConfig1092(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1092(-1);
    }

    sdb::CarConfig1093 IPCPSignalManager::getcarconfig1093() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1093));
        }
        if (signal.has_value()){
            return sdb::CarConfig1093(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1093(-1);
    }

    sdb::CarConfig1094 IPCPSignalManager::getcarconfig1094() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1094));
        }
        if (signal.has_value()){
            return sdb::CarConfig1094(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1094(-1);
    }

    sdb::CarConfig1095 IPCPSignalManager::getcarconfig1095() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1095));
        }
        if (signal.has_value()){
            return sdb::CarConfig1095(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1095(-1);
    }

    sdb::CarConfig1096 IPCPSignalManager::getcarconfig1096() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1096));
        }
        if (signal.has_value()){
            return sdb::CarConfig1096(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1096(-1);
    }

    sdb::CarConfig1097 IPCPSignalManager::getcarconfig1097() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1097));
        }
        if (signal.has_value()){
            return sdb::CarConfig1097(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1097(-1);
    }

    sdb::CarConfig1098 IPCPSignalManager::getcarconfig1098() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1098));
        }
        if (signal.has_value()){
            return sdb::CarConfig1098(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1098(-1);
    }

    sdb::CarConfig1099 IPCPSignalManager::getcarconfig1099() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1099));
        }
        if (signal.has_value()){
            return sdb::CarConfig1099(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1099(-1);
    }

    sdb::CarConfig1100 IPCPSignalManager::getcarconfig1100() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1100));
        }
        if (signal.has_value()){
            return sdb::CarConfig1100(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1100(-1);
    }

    sdb::CarConfig1101 IPCPSignalManager::getcarconfig1101() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1101));
        }
        if (signal.has_value()){
            return sdb::CarConfig1101(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1101(-1);
    }

    sdb::CarConfig1102 IPCPSignalManager::getcarconfig1102() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1102));
        }
        if (signal.has_value()){
            return sdb::CarConfig1102(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1102(-1);
    }

    sdb::CarConfig1103 IPCPSignalManager::getcarconfig1103() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1103));
        }
        if (signal.has_value()){
            return sdb::CarConfig1103(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1103(-1);
    }

    sdb::CarConfig1104 IPCPSignalManager::getcarconfig1104() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1104));
        }
        if (signal.has_value()){
            return sdb::CarConfig1104(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1104(-1);
    }

    sdb::CarConfig1105 IPCPSignalManager::getcarconfig1105() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1105));
        }
        if (signal.has_value()){
            return sdb::CarConfig1105(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1105(-1);
    }

    sdb::CarConfig1106 IPCPSignalManager::getcarconfig1106() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1106));
        }
        if (signal.has_value()){
            return sdb::CarConfig1106(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1106(-1);
    }

    sdb::CarConfig1107 IPCPSignalManager::getcarconfig1107() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1107));
        }
        if (signal.has_value()){
            return sdb::CarConfig1107(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1107(-1);
    }

    sdb::CarConfig1108 IPCPSignalManager::getcarconfig1108() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1108));
        }
        if (signal.has_value()){
            return sdb::CarConfig1108(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1108(-1);
    }

    sdb::CarConfig1109 IPCPSignalManager::getcarconfig1109() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1109));
        }
        if (signal.has_value()){
            return sdb::CarConfig1109(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1109(-1);
    }

    sdb::CarConfig1110 IPCPSignalManager::getcarconfig1110() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1110));
        }
        if (signal.has_value()){
            return sdb::CarConfig1110(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1110(-1);
    }

    sdb::CarConfig1111 IPCPSignalManager::getcarconfig1111() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1111));
        }
        if (signal.has_value()){
            return sdb::CarConfig1111(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1111(-1);
    }

    sdb::CarConfig1112 IPCPSignalManager::getcarconfig1112() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1112));
        }
        if (signal.has_value()){
            return sdb::CarConfig1112(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1112(-1);
    }

    sdb::CarConfig1113 IPCPSignalManager::getcarconfig1113() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1113));
        }
        if (signal.has_value()){
            return sdb::CarConfig1113(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1113(-1);
    }

    sdb::CarConfig1114 IPCPSignalManager::getcarconfig1114() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1114));
        }
        if (signal.has_value()){
            return sdb::CarConfig1114(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1114(-1);
    }

    sdb::CarConfig1115 IPCPSignalManager::getcarconfig1115() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1115));
        }
        if (signal.has_value()){
            return sdb::CarConfig1115(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1115(-1);
    }

    sdb::CarConfig1116 IPCPSignalManager::getcarconfig1116() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1116));
        }
        if (signal.has_value()){
            return sdb::CarConfig1116(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1116(-1);
    }

    sdb::CarConfig1117 IPCPSignalManager::getcarconfig1117() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1117));
        }
        if (signal.has_value()){
            return sdb::CarConfig1117(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1117(-1);
    }

    sdb::CarConfig1118 IPCPSignalManager::getcarconfig1118() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1118));
        }
        if (signal.has_value()){
            return sdb::CarConfig1118(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1118(-1);
    }

    sdb::CarConfig1119 IPCPSignalManager::getcarconfig1119() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1119));
        }
        if (signal.has_value()){
            return sdb::CarConfig1119(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1119(-1);
    }

    sdb::CarConfig1120 IPCPSignalManager::getcarconfig1120() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1120));
        }
        if (signal.has_value()){
            return sdb::CarConfig1120(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1120(-1);
    }

    sdb::CarConfig1121 IPCPSignalManager::getcarconfig1121() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1121));
        }
        if (signal.has_value()){
            return sdb::CarConfig1121(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1121(-1);
    }

    sdb::CarConfig1122 IPCPSignalManager::getcarconfig1122() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1122));
        }
        if (signal.has_value()){
            return sdb::CarConfig1122(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1122(-1);
    }

    sdb::CarConfig1123 IPCPSignalManager::getcarconfig1123() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1123));
        }
        if (signal.has_value()){
            return sdb::CarConfig1123(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1123(-1);
    }

    sdb::CarConfig1124 IPCPSignalManager::getcarconfig1124() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1124));
        }
        if (signal.has_value()){
            return sdb::CarConfig1124(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1124(-1);
    }

    sdb::CarConfig1125 IPCPSignalManager::getcarconfig1125() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1125));
        }
        if (signal.has_value()){
            return sdb::CarConfig1125(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1125(-1);
    }

    sdb::CarConfig1126 IPCPSignalManager::getcarconfig1126() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1126));
        }
        if (signal.has_value()){
            return sdb::CarConfig1126(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1126(-1);
    }

    sdb::CarConfig1127 IPCPSignalManager::getcarconfig1127() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1127));
        }
        if (signal.has_value()){
            return sdb::CarConfig1127(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1127(-1);
    }

    sdb::CarConfig1128 IPCPSignalManager::getcarconfig1128() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1128));
        }
        if (signal.has_value()){
            return sdb::CarConfig1128(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1128(-1);
    }

    sdb::CarConfig1129 IPCPSignalManager::getcarconfig1129() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1129));
        }
        if (signal.has_value()){
            return sdb::CarConfig1129(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1129(-1);
    }

    sdb::CarConfig1130 IPCPSignalManager::getcarconfig1130() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1130));
        }
        if (signal.has_value()){
            return sdb::CarConfig1130(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1130(-1);
    }

    sdb::CarConfig1131 IPCPSignalManager::getcarconfig1131() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1131));
        }
        if (signal.has_value()){
            return sdb::CarConfig1131(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1131(-1);
    }

    sdb::CarConfig1132 IPCPSignalManager::getcarconfig1132() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1132));
        }
        if (signal.has_value()){
            return sdb::CarConfig1132(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1132(-1);
    }

    sdb::CarConfig1133 IPCPSignalManager::getcarconfig1133() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1133));
        }
        if (signal.has_value()){
            return sdb::CarConfig1133(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1133(-1);
    }

    sdb::CarConfig1134 IPCPSignalManager::getcarconfig1134() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1134));
        }
        if (signal.has_value()){
            return sdb::CarConfig1134(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1134(-1);
    }

    sdb::CarConfig1135 IPCPSignalManager::getcarconfig1135() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1135));
        }
        if (signal.has_value()){
            return sdb::CarConfig1135(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1135(-1);
    }

    sdb::CarConfig1136 IPCPSignalManager::getcarconfig1136() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1136));
        }
        if (signal.has_value()){
            return sdb::CarConfig1136(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1136(-1);
    }

    sdb::CarConfig1137 IPCPSignalManager::getcarconfig1137() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1137));
        }
        if (signal.has_value()){
            return sdb::CarConfig1137(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1137(-1);
    }

    sdb::CarConfig1138 IPCPSignalManager::getcarconfig1138() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1138));
        }
        if (signal.has_value()){
            return sdb::CarConfig1138(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1138(-1);
    }

    sdb::CarConfig1139 IPCPSignalManager::getcarconfig1139() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1139));
        }
        if (signal.has_value()){
            return sdb::CarConfig1139(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1139(-1);
    }

    sdb::CarConfig1140 IPCPSignalManager::getcarconfig1140() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1140));
        }
        if (signal.has_value()){
            return sdb::CarConfig1140(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1140(-1);
    }

    sdb::CarConfig1141 IPCPSignalManager::getcarconfig1141() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1141));
        }
        if (signal.has_value()){
            return sdb::CarConfig1141(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1141(-1);
    }

    sdb::Carconfig1142 IPCPSignalManager::getcarconfig1142() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1142));
        }
        if (signal.has_value()){
            return sdb::Carconfig1142(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1142(-1);
    }

    sdb::Carconfig1143 IPCPSignalManager::getcarconfig1143() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1143));
        }
        if (signal.has_value()){
            return sdb::Carconfig1143(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1143(-1);
    }

    sdb::CarConfig1144 IPCPSignalManager::getcarconfig1144() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1144));
        }
        if (signal.has_value()){
            return sdb::CarConfig1144(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1144(-1);
    }

    sdb::CarConfig1145 IPCPSignalManager::getcarconfig1145() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1145));
        }
        if (signal.has_value()){
            return sdb::CarConfig1145(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1145(-1);
    }

    sdb::CarConfig1146 IPCPSignalManager::getcarconfig1146() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1146));
        }
        if (signal.has_value()){
            return sdb::CarConfig1146(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1146(-1);
    }

    sdb::CarConfig1147 IPCPSignalManager::getcarconfig1147() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1147));
        }
        if (signal.has_value()){
            return sdb::CarConfig1147(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1147(-1);
    }

    sdb::CarConfig1148 IPCPSignalManager::getcarconfig1148() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1148));
        }
        if (signal.has_value()){
            return sdb::CarConfig1148(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1148(-1);
    }

    sdb::CarConfig1149 IPCPSignalManager::getcarconfig1149() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1149));
        }
        if (signal.has_value()){
            return sdb::CarConfig1149(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1149(-1);
    }

    sdb::CarConfig1150 IPCPSignalManager::getcarconfig1150() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1150));
        }
        if (signal.has_value()){
            return sdb::CarConfig1150(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1150(-1);
    }

    sdb::CarConfig1151 IPCPSignalManager::getcarconfig1151() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1151));
        }
        if (signal.has_value()){
            return sdb::CarConfig1151(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1151(-1);
    }

    sdb::CarConfig1152 IPCPSignalManager::getcarconfig1152() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1152));
        }
        if (signal.has_value()){
            return sdb::CarConfig1152(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1152(-1);
    }

    sdb::CarConfig1153 IPCPSignalManager::getcarconfig1153() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1153));
        }
        if (signal.has_value()){
            return sdb::CarConfig1153(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1153(-1);
    }

    sdb::CarConfig1154 IPCPSignalManager::getcarconfig1154() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1154));
        }
        if (signal.has_value()){
            return sdb::CarConfig1154(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1154(-1);
    }

    sdb::CarConfig1155 IPCPSignalManager::getcarconfig1155() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1155));
        }
        if (signal.has_value()){
            return sdb::CarConfig1155(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1155(-1);
    }

    sdb::CarConfig1156 IPCPSignalManager::getcarconfig1156() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1156));
        }
        if (signal.has_value()){
            return sdb::CarConfig1156(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1156(-1);
    }

    sdb::CarConfig1157 IPCPSignalManager::getcarconfig1157() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1157));
        }
        if (signal.has_value()){
            return sdb::CarConfig1157(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1157(-1);
    }

    sdb::CarConfig1158 IPCPSignalManager::getcarconfig1158() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1158));
        }
        if (signal.has_value()){
            return sdb::CarConfig1158(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1158(-1);
    }

    sdb::CarConfig1159 IPCPSignalManager::getcarconfig1159() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1159));
        }
        if (signal.has_value()){
            return sdb::CarConfig1159(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1159(-1);
    }

    sdb::CarConfig1160 IPCPSignalManager::getcarconfig1160() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1160));
        }
        if (signal.has_value()){
            return sdb::CarConfig1160(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1160(-1);
    }

    sdb::CarConfig1161 IPCPSignalManager::getcarconfig1161() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1161));
        }
        if (signal.has_value()){
            return sdb::CarConfig1161(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1161(-1);
    }

    sdb::CarConfig1162 IPCPSignalManager::getcarconfig1162() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1162));
        }
        if (signal.has_value()){
            return sdb::CarConfig1162(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1162(-1);
    }

    sdb::CarConfig1163 IPCPSignalManager::getcarconfig1163() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1163));
        }
        if (signal.has_value()){
            return sdb::CarConfig1163(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1163(-1);
    }

    sdb::CarConfig1164 IPCPSignalManager::getcarconfig1164() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1164));
        }
        if (signal.has_value()){
            return sdb::CarConfig1164(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1164(-1);
    }

    sdb::CarConfig1165 IPCPSignalManager::getcarconfig1165() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1165));
        }
        if (signal.has_value()){
            return sdb::CarConfig1165(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1165(-1);
    }

    sdb::Carconfig1166 IPCPSignalManager::getcarconfig1166() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1166));
        }
        if (signal.has_value()){
            return sdb::Carconfig1166(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1166(-1);
    }

    sdb::CarConfig1167 IPCPSignalManager::getcarconfig1167() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1167));
        }
        if (signal.has_value()){
            return sdb::CarConfig1167(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1167(-1);
    }

    sdb::CarConfig1168 IPCPSignalManager::getcarconfig1168() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1168));
        }
        if (signal.has_value()){
            return sdb::CarConfig1168(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1168(-1);
    }

    sdb::CarConfig1169 IPCPSignalManager::getcarconfig1169() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1169));
        }
        if (signal.has_value()){
            return sdb::CarConfig1169(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1169(-1);
    }

    sdb::CarConfig1170 IPCPSignalManager::getcarconfig1170() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1170));
        }
        if (signal.has_value()){
            return sdb::CarConfig1170(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1170(-1);
    }

    sdb::CarConfig1171 IPCPSignalManager::getcarconfig1171() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1171));
        }
        if (signal.has_value()){
            return sdb::CarConfig1171(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1171(-1);
    }

    sdb::CarConfig1172 IPCPSignalManager::getcarconfig1172() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1172));
        }
        if (signal.has_value()){
            return sdb::CarConfig1172(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1172(-1);
    }

    sdb::CarConfig1173 IPCPSignalManager::getcarconfig1173() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1173));
        }
        if (signal.has_value()){
            return sdb::CarConfig1173(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1173(-1);
    }

    sdb::CarConfig1174 IPCPSignalManager::getcarconfig1174() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1174));
        }
        if (signal.has_value()){
            return sdb::CarConfig1174(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1174(-1);
    }

    sdb::CarConfig1175 IPCPSignalManager::getcarconfig1175() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1175));
        }
        if (signal.has_value()){
            return sdb::CarConfig1175(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1175(-1);
    }

    sdb::CarConfig1176 IPCPSignalManager::getcarconfig1176() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1176));
        }
        if (signal.has_value()){
            return sdb::CarConfig1176(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1176(-1);
    }

    sdb::CarConfig1177 IPCPSignalManager::getcarconfig1177() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1177));
        }
        if (signal.has_value()){
            return sdb::CarConfig1177(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1177(-1);
    }

    sdb::CarConfig1178 IPCPSignalManager::getcarconfig1178() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1178));
        }
        if (signal.has_value()){
            return sdb::CarConfig1178(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1178(-1);
    }

    sdb::CarConfig1179 IPCPSignalManager::getcarconfig1179() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1179));
        }
        if (signal.has_value()){
            return sdb::CarConfig1179(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1179(-1);
    }

    sdb::CarConfig1180 IPCPSignalManager::getcarconfig1180() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1180));
        }
        if (signal.has_value()){
            return sdb::CarConfig1180(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1180(-1);
    }

    sdb::CarConfig1181 IPCPSignalManager::getcarconfig1181() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1181));
        }
        if (signal.has_value()){
            return sdb::CarConfig1181(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1181(-1);
    }

    sdb::CarConfig1182 IPCPSignalManager::getcarconfig1182() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1182));
        }
        if (signal.has_value()){
            return sdb::CarConfig1182(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1182(-1);
    }

    sdb::CarConfig1183 IPCPSignalManager::getcarconfig1183() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1183));
        }
        if (signal.has_value()){
            return sdb::CarConfig1183(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1183(-1);
    }

    sdb::CarConfig1184 IPCPSignalManager::getcarconfig1184() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1184));
        }
        if (signal.has_value()){
            return sdb::CarConfig1184(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1184(-1);
    }

    sdb::CarConfig1185 IPCPSignalManager::getcarconfig1185() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1185));
        }
        if (signal.has_value()){
            return sdb::CarConfig1185(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1185(-1);
    }

    sdb::CarConfig1186 IPCPSignalManager::getcarconfig1186() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1186));
        }
        if (signal.has_value()){
            return sdb::CarConfig1186(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1186(-1);
    }

    sdb::CarConfig1187 IPCPSignalManager::getcarconfig1187() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1187));
        }
        if (signal.has_value()){
            return sdb::CarConfig1187(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1187(-1);
    }

    sdb::CarConfig1188 IPCPSignalManager::getcarconfig1188() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1188));
        }
        if (signal.has_value()){
            return sdb::CarConfig1188(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1188(-1);
    }

    sdb::CarConfig1189 IPCPSignalManager::getcarconfig1189() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1189));
        }
        if (signal.has_value()){
            return sdb::CarConfig1189(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1189(-1);
    }

    sdb::CarConfig1190 IPCPSignalManager::getcarconfig1190() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1190));
        }
        if (signal.has_value()){
            return sdb::CarConfig1190(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1190(-1);
    }

    sdb::CarConfig1191 IPCPSignalManager::getcarconfig1191() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1191));
        }
        if (signal.has_value()){
            return sdb::CarConfig1191(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1191(-1);
    }

    sdb::CarConfig1192 IPCPSignalManager::getcarconfig1192() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1192));
        }
        if (signal.has_value()){
            return sdb::CarConfig1192(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1192(-1);
    }

    sdb::CarConfig1193 IPCPSignalManager::getcarconfig1193() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1193));
        }
        if (signal.has_value()){
            return sdb::CarConfig1193(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1193(-1);
    }

    sdb::CarConfig1194 IPCPSignalManager::getcarconfig1194() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1194));
        }
        if (signal.has_value()){
            return sdb::CarConfig1194(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1194(-1);
    }

    sdb::CarConfig1195 IPCPSignalManager::getcarconfig1195() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1195));
        }
        if (signal.has_value()){
            return sdb::CarConfig1195(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1195(-1);
    }

    sdb::CarConfig1196 IPCPSignalManager::getcarconfig1196() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1196));
        }
        if (signal.has_value()){
            return sdb::CarConfig1196(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1196(-1);
    }

    sdb::CarConfig1197 IPCPSignalManager::getcarconfig1197() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1197));
        }
        if (signal.has_value()){
            return sdb::CarConfig1197(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1197(-1);
    }

    sdb::CarConfig1198 IPCPSignalManager::getcarconfig1198() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1198));
        }
        if (signal.has_value()){
            return sdb::CarConfig1198(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1198(-1);
    }

    sdb::CarConfig1199 IPCPSignalManager::getcarconfig1199() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1199));
        }
        if (signal.has_value()){
            return sdb::CarConfig1199(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1199(-1);
    }

    sdb::CarConfig1200 IPCPSignalManager::getcarconfig1200() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1200));
        }
        if (signal.has_value()){
            return sdb::CarConfig1200(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1200(-1);
    }

    sdb::Carconfig1201 IPCPSignalManager::getcarconfig1201() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1201));
        }
        if (signal.has_value()){
            return sdb::Carconfig1201(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1201(-1);
    }

    sdb::Carconfig1202 IPCPSignalManager::getcarconfig1202() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1202));
        }
        if (signal.has_value()){
            return sdb::Carconfig1202(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1202(-1);
    }

    sdb::Carconfig1203 IPCPSignalManager::getcarconfig1203() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1203));
        }
        if (signal.has_value()){
            return sdb::Carconfig1203(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1203(-1);
    }

    sdb::Carconfig1204 IPCPSignalManager::getcarconfig1204() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1204));
        }
        if (signal.has_value()){
            return sdb::Carconfig1204(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1204(-1);
    }

    sdb::Carconfig1205 IPCPSignalManager::getcarconfig1205() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1205));
        }
        if (signal.has_value()){
            return sdb::Carconfig1205(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1205(-1);
    }

    sdb::Carconfig1206 IPCPSignalManager::getcarconfig1206() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1206));
        }
        if (signal.has_value()){
            return sdb::Carconfig1206(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1206(-1);
    }

    sdb::Carconfig1207 IPCPSignalManager::getcarconfig1207() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1207));
        }
        if (signal.has_value()){
            return sdb::Carconfig1207(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1207(-1);
    }

    sdb::Carconfig1208 IPCPSignalManager::getcarconfig1208() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1208));
        }
        if (signal.has_value()){
            return sdb::Carconfig1208(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1208(-1);
    }

    sdb::Carconfig1209 IPCPSignalManager::getcarconfig1209() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1209));
        }
        if (signal.has_value()){
            return sdb::Carconfig1209(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1209(-1);
    }

    sdb::Carconfig1210 IPCPSignalManager::getcarconfig1210() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1210));
        }
        if (signal.has_value()){
            return sdb::Carconfig1210(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1210(-1);
    }

    sdb::Carconfig1211 IPCPSignalManager::getcarconfig1211() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1211));
        }
        if (signal.has_value()){
            return sdb::Carconfig1211(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1211(-1);
    }

    sdb::Carconfig1212 IPCPSignalManager::getcarconfig1212() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1212));
        }
        if (signal.has_value()){
            return sdb::Carconfig1212(signal->value.int32Values[0]);
        }
        return sdb::Carconfig1212(-1);
    }

    sdb::CarConfig1213 IPCPSignalManager::getcarconfig1213() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1213));
        }
        if (signal.has_value()){
            return sdb::CarConfig1213(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1213(-1);
    }

    sdb::CarConfig1214 IPCPSignalManager::getcarconfig1214() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1214));
        }
        if (signal.has_value()){
            return sdb::CarConfig1214(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1214(-1);
    }

    sdb::CarConfig1215 IPCPSignalManager::getcarconfig1215() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1215));
        }
        if (signal.has_value()){
            return sdb::CarConfig1215(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1215(-1);
    }

    sdb::CarConfig1216 IPCPSignalManager::getcarconfig1216() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1216));
        }
        if (signal.has_value()){
            return sdb::CarConfig1216(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1216(-1);
    }

    sdb::CarConfig1217 IPCPSignalManager::getcarconfig1217() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1217));
        }
        if (signal.has_value()){
            return sdb::CarConfig1217(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1217(-1);
    }

    sdb::CarConfig1218 IPCPSignalManager::getcarconfig1218() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1218));
        }
        if (signal.has_value()){
            return sdb::CarConfig1218(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1218(-1);
    }

    sdb::CarConfig1219 IPCPSignalManager::getcarconfig1219() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1219));
        }
        if (signal.has_value()){
            return sdb::CarConfig1219(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1219(-1);
    }

    sdb::CarConfig1220 IPCPSignalManager::getcarconfig1220() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1220));
        }
        if (signal.has_value()){
            return sdb::CarConfig1220(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1220(-1);
    }

    sdb::CarConfig1221 IPCPSignalManager::getcarconfig1221() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1221));
        }
        if (signal.has_value()){
            return sdb::CarConfig1221(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1221(-1);
    }

    sdb::CarConfig1222 IPCPSignalManager::getcarconfig1222() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1222));
        }
        if (signal.has_value()){
            return sdb::CarConfig1222(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1222(-1);
    }

    sdb::CarConfig1223 IPCPSignalManager::getcarconfig1223() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1223));
        }
        if (signal.has_value()){
            return sdb::CarConfig1223(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1223(-1);
    }

    sdb::CarConfig1224 IPCPSignalManager::getcarconfig1224() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1224));
        }
        if (signal.has_value()){
            return sdb::CarConfig1224(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1224(-1);
    }

    sdb::CarConfig1225 IPCPSignalManager::getcarconfig1225() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1225));
        }
        if (signal.has_value()){
            return sdb::CarConfig1225(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1225(-1);
    }

    sdb::CarConfig1226 IPCPSignalManager::getcarconfig1226() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1226));
        }
        if (signal.has_value()){
            return sdb::CarConfig1226(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1226(-1);
    }

    sdb::CarConfig1227 IPCPSignalManager::getcarconfig1227() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1227));
        }
        if (signal.has_value()){
            return sdb::CarConfig1227(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1227(-1);
    }

    sdb::CarConfig1228 IPCPSignalManager::getcarconfig1228() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1228));
        }
        if (signal.has_value()){
            return sdb::CarConfig1228(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1228(-1);
    }

    sdb::CarConfig1229 IPCPSignalManager::getcarconfig1229() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1229));
        }
        if (signal.has_value()){
            return sdb::CarConfig1229(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1229(-1);
    }

    sdb::CarConfig1230 IPCPSignalManager::getcarconfig1230() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1230));
        }
        if (signal.has_value()){
            return sdb::CarConfig1230(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1230(-1);
    }

    sdb::CarConfig1231 IPCPSignalManager::getcarconfig1231() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1231));
        }
        if (signal.has_value()){
            return sdb::CarConfig1231(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1231(-1);
    }

    sdb::CarConfig1232 IPCPSignalManager::getcarconfig1232() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1232));
        }
        if (signal.has_value()){
            return sdb::CarConfig1232(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1232(-1);
    }

    sdb::CarConfig1233 IPCPSignalManager::getcarconfig1233() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1233));
        }
        if (signal.has_value()){
            return sdb::CarConfig1233(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1233(-1);
    }

    sdb::CarConfig1234 IPCPSignalManager::getcarconfig1234() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1234));
        }
        if (signal.has_value()){
            return sdb::CarConfig1234(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1234(-1);
    }

    sdb::CarConfig1235 IPCPSignalManager::getcarconfig1235() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1235));
        }
        if (signal.has_value()){
            return sdb::CarConfig1235(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1235(-1);
    }

    sdb::CarConfig1236 IPCPSignalManager::getcarconfig1236() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1236));
        }
        if (signal.has_value()){
            return sdb::CarConfig1236(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1236(-1);
    }

    sdb::CarConfig1237 IPCPSignalManager::getcarconfig1237() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1237));
        }
        if (signal.has_value()){
            return sdb::CarConfig1237(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1237(-1);
    }

    sdb::CarConfig1238 IPCPSignalManager::getcarconfig1238() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1238));
        }
        if (signal.has_value()){
            return sdb::CarConfig1238(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1238(-1);
    }

    sdb::CarConfig1239 IPCPSignalManager::getcarconfig1239() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1239));
        }
        if (signal.has_value()){
            return sdb::CarConfig1239(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1239(-1);
    }

    sdb::CarConfig1240 IPCPSignalManager::getcarconfig1240() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1240));
        }
        if (signal.has_value()){
            return sdb::CarConfig1240(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1240(-1);
    }

    sdb::CarConfig1241 IPCPSignalManager::getcarconfig1241() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1241));
        }
        if (signal.has_value()){
            return sdb::CarConfig1241(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1241(-1);
    }

    sdb::CarConfig1242 IPCPSignalManager::getcarconfig1242() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1242));
        }
        if (signal.has_value()){
            return sdb::CarConfig1242(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1242(-1);
    }

    sdb::CarConfig1243 IPCPSignalManager::getcarconfig1243() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1243));
        }
        if (signal.has_value()){
            return sdb::CarConfig1243(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1243(-1);
    }

    sdb::CarConfig1244 IPCPSignalManager::getcarconfig1244() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1244));
        }
        if (signal.has_value()){
            return sdb::CarConfig1244(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1244(-1);
    }

    sdb::CarConfig1245 IPCPSignalManager::getcarconfig1245() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1245));
        }
        if (signal.has_value()){
            return sdb::CarConfig1245(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1245(-1);
    }

    sdb::CarConfig1246 IPCPSignalManager::getcarconfig1246() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1246));
        }
        if (signal.has_value()){
            return sdb::CarConfig1246(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1246(-1);
    }

    sdb::CarConfig1247 IPCPSignalManager::getcarconfig1247() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1247));
        }
        if (signal.has_value()){
            return sdb::CarConfig1247(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1247(-1);
    }

    sdb::CarConfig1248 IPCPSignalManager::getcarconfig1248() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1248));
        }
        if (signal.has_value()){
            return sdb::CarConfig1248(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1248(-1);
    }

    sdb::CarConfig1249 IPCPSignalManager::getcarconfig1249() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1249));
        }
        if (signal.has_value()){
            return sdb::CarConfig1249(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1249(-1);
    }

    sdb::CarConfig1250 IPCPSignalManager::getcarconfig1250() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1250));
        }
        if (signal.has_value()){
            return sdb::CarConfig1250(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1250(-1);
    }

    sdb::CarConfig1251 IPCPSignalManager::getcarconfig1251() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1251));
        }
        if (signal.has_value()){
            return sdb::CarConfig1251(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1251(-1);
    }

    sdb::CarConfig1252 IPCPSignalManager::getcarconfig1252() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1252));
        }
        if (signal.has_value()){
            return sdb::CarConfig1252(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1252(-1);
    }

    sdb::CarConfig1253 IPCPSignalManager::getcarconfig1253() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1253));
        }
        if (signal.has_value()){
            return sdb::CarConfig1253(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1253(-1);
    }

    sdb::CarConfig1254 IPCPSignalManager::getcarconfig1254() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1254));
        }
        if (signal.has_value()){
            return sdb::CarConfig1254(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1254(-1);
    }

    sdb::CarConfig1255 IPCPSignalManager::getcarconfig1255() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::carconfig1255));
        }
        if (signal.has_value()){
            return sdb::CarConfig1255(signal->value.int32Values[0]);
        }
        return sdb::CarConfig1255(-1);
    }

    sdb::Timeout IPCPSignalManager::getAsyALgtIndcrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALgtIndcrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAsyALatIndcrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyALatIndcrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAsyHandsOffIndcrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyHandsOffIndcrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getCrsCtrlrStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CrsCtrlrStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAdjSpdLimnStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AdjSpdLimnStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDrvrSeatExtAdjAllowdTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatExtAdjAllowdTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getTrOpenerStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrOpenerStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getTopPosHmiFeedBackTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TopPosHmiFeedBackTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getEscStTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EscStTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getExtrLtgStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrLtgStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getCarLocatorActvStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarLocatorActvStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDispHvBattLvlOfChrgTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DispHvBattLvlOfChrgTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getOnBdChrgrUActTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrUActTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getHvBattUDcTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattUDcTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getOnBdChrgrIActTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrIActTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getHvBattIDc1Timeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattIDc1Timeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getChrgnSpdTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnSpdTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getHvBattChrgnTiEstimdTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::HvBattChrgnTiEstimdTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getMaintainBattTFbTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MaintainBattTFbTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getMaxACInpISetFdbTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MaxACInpISetFdbTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getClimaOvrHeatProActvStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ClimaOvrHeatProActvStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDrvrPfmncSwitchStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrPfmncSwitchStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDchaUActTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaUActTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDchaIActTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaIActTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDchaEgyActTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DchaEgyActTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getChrgLidDCorAcDcStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgLidDCorAcDcStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLockgCenStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LockgCenStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getChrgnOrDisChrgnStsFbTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgnOrDisChrgnStsFbTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getOnBdChrgrHndlSts1Timeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::OnBdChrgrHndlSts1Timeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDCChrgnHndlStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DCChrgnHndlStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDriModButTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DriModButTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getTrlrPrsntTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::TrlrPrsntTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getWPCModuleStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WPCModuleStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getWPCModuleStsBNCM2Timeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::WPCModuleStsBNCM2Timeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getActvnOfIndcrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ActvnOfIndcrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getSteerErrReqTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SteerErrReqTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getCarLoctrHornLiSetActvTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::CarLoctrHornLiSetActvTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDispOfPrpsnModForEvTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DispOfPrpsnModForEvTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getBrkModSoftSwtStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::BrkModSoftSwtStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getChrgLidAcStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChrgLidAcStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getEPedlModStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::EPedlModStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAutHldSoftSwtEnaStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AutHldSoftSwtEnaStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getMirrFoldStsAtDrvrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MirrFoldStsAtDrvrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getMirrFoldStsAtPassTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::MirrFoldStsAtPassTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getFrntWiprLvrCmd2Timeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::FrntWiprLvrCmd2Timeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getSoftBtnSwtStCfmdTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::SoftBtnSwtStCfmdTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLeFrntTireMsgPTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgPTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRiFrntTireMsgPTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgPTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLeReTireMsgPTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgPTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRiReTireMsgPTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgPTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLeFrntTireMsgTTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeFrntTireMsgTTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRiFrntTireMsgTTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiFrntTireMsgTTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLeReTireMsgTTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LeReTireMsgTTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRiReTireMsgTTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RiReTireMsgTTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAsyLaneKeepAidStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyLaneKeepAidStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getAsyFctnIhbtByTrlrTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::AsyFctnIhbtByTrlrTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getLnchModStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::LnchModStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getExtrMirrFoldSetStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ExtrMirrFoldSetStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getChgPreSetTempButtonFbTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ChgPreSetTempButtonFbTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getDrvrSeatStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::DrvrSeatStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRowFrstPassODSStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowFrstPassODSStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRowSecLeODSStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecLeODSStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getRowSecRiODSStsTimeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::RowSecRiODSStsTimeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    sdb::Timeout IPCPSignalManager::getProfPenSts1Timeout() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(SignalRX::ProfPenSts1Timeout));
        }
        if (signal.has_value()){
            return sdb::Timeout(signal->value.int32Values[0]);
        }
        return sdb::Timeout(-1);
    }

    void IPCPSignalManager::setCB_LogServiceStatusAP(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_LogServiceStatusAP);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AppLog_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AppLog_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_ApVp_InterfaceVersion(const InterfaceVersion& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_ApVp_InterfaceVersion);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntFuncType IPCPSignalManager::getPA_ErrorReport() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_ErrorReport));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    void IPCPSignalManager::setCB_AR_WarningVlo(sdb::Co2Lvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AR_WarningVlo);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AR_EcallState(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AR_EcallState);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntFuncType IPCPSignalManager::getPA_AR_WarningVlo() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_AR_WarningVlo));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    void IPCPSignalManager::setCB_WDC_AutoFrontDefrost(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_WDC_AutoFrontDefrost);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_WDC_AutoRearDefrost(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_WDC_AutoRearDefrost);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_AC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_AC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_Auto(sdb::LongPresBtn value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_Auto);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_Rcirc(sdb::LongPresBtn value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_Rcirc);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ModeFrstLeft(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ModeFrstLeft);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ModeFrstRight(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ModeFrstRight);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ModeSec(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ModeSec);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_MaxAC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_MaxAC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_FanLevel(sdb::HmiHvacFanLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_FanLevel);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_LeftTemp(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_LeftTemp);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_RightTemp(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_RightTemp);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_MaxDefrost(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_MaxDefrost);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_FrontDefrost(sdb::ElecDefrostSts value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_FrontDefrost);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_RearDefrost(sdb::ElecDefrostSts value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_RearDefrost);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_Sync(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_Sync);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_AirCtrlOff(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_AirCtrlOff);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_HvacReCtrl(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_HvacReCtrl);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecLeftTemp(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecLeftTemp);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecRightTemp(int32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecRightTemp);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecFanLevel(sdb::HmiHvacFanLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecFanLevel);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecRowOnOffSwith(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecRowOnOffSwith);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_IntelliClimaPop(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_IntelliClimaPop);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ClmSmtAmbientPop(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ClmSmtAmbientPop);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ClmSmtCloSecPop(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ClmSmtCloSecPop);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ClmSmtCloPassPop(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ClmSmtCloPassPop);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecLockClimaSw(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecLockClimaSw);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecAutoSw(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecAutoSw);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_GClean(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_GClean);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecClimaAutoSwith(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecClimaAutoSwith);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ModeSecRi(sdb::HmiCmptmtAirDistbnFrnt value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ModeSecRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_FanLevelRi(sdb::HmiHvacFanLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_FanLevelRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecFanLevelRi(sdb::HmiHvacFanLvl value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecFanLevelRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_AutoRi(sdb::LongPresBtn value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_AutoRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_SecAutoSwRi(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_SecAutoSwRi);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_PassTempSync(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_PassTempSync);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_ClimSmartOnOrOff(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_ClimSmartOnOrOff);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_RestPattern(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_RestPattern);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_DrvrCtrlSwt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_DrvrCtrlSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_PassCtrlSwt(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_PassCtrlSwt);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_Ventilation(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_Ventilation);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CL_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CL_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_AC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_AC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_Auto() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_Auto));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_Recirc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_Recirc));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ModeFrstLeft() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ModeFrstLeft));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ModeFrstRight() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ModeFrstRight));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ModeSec() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ModeSec));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_MaxAC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_MaxAC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_FanLevel() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_FanLevel));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_LeftTemp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_LeftTemp));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_RightTemp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_RightTemp));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_MaxDefrost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_MaxDefrost));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_WDC_AutoFrontDefrost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_WDC_AutoFrontDefrost));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_WDC_AutoRearDefrost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_WDC_AutoRearDefrost));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_FrontDefrost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_FrontDefrost));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_RearDefrost() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_RearDefrost));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_Sync() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_Sync));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_AirCtrlOff() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_AirCtrlOff));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_HvacReCtr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_HvacReCtr));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecLeftTemp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecLeftTemp));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecRightTemp() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecRightTemp));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecFanLevel() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecFanLevel));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_Ventilation() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_Ventilation));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_FrntDefrostPopup() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_FrntDefrostPopup));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_RearDefrostPopup() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_RearDefrostPopup));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecRowOnOffSwith() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecRowOnOffSwith));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_IntelliClimaPop() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_IntelliClimaPop));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ClmSmtAmbientPop() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ClmSmtAmbientPop));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ClmSmtCloSecPop() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ClmSmtCloSecPop));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ClmSmtCloPassPop() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ClmSmtCloPassPop));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecLockClimaSw() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecLockClimaSw));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecAutoSw() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecAutoSw));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_GClean() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_GClean));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecClimaAutoSwith() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecClimaAutoSwith));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_IntelliClimaEgySavePop() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_IntelliClimaEgySavePop));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ModeSecRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ModeSecRi));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_FanLevelRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_FanLevelRi));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecFanLevelRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecFanLevelRi));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_AutoRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_AutoRi));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_SecAutoSwRi() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_SecAutoSwRi));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_PassTempSync() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_PassTempSync));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_ClimSmartOnOrOff() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_ClimSmartOnOrOff));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_DrvrCtrlSwt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_DrvrCtrlSwt));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_PassCtrlSwt() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_PassCtrlSwt));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_CL_IntelligentlyCleanin() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CL_IntelligentlyCleanin));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    void IPCPSignalManager::setCB_Dcm_D903_PAS_WAM_Video_in(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D903_PAS_WAM_Video_in);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_D904_DVR_Video_IN(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D904_DVR_Video_IN);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_D905_Gesture_Video_IN(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D905_Gesture_Video_IN);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_D906_Chat_Video_IN(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D906_Chat_Video_IN);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_D912_PSD_MONITOR_EN(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D912_PSD_MONITOR_EN);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CSD_MONITOR_EN(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CSD_MONITOR_EN);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_IHU_connected_WIFI_NAME(const std::array<uint8_t,32>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_IHU_connected_WIFI_NAME);
        signal.value.int32Values.resize(32,0);
        for(size_t i=0;i<32;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_RVDC_Statu(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_RVDC_Statu);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_IHU_WIFI_connection(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_IHU_WIFI_connection);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AP_partition_percentage(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AP_partition_percentage);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_D94E_DHU_logging_and_log_files(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_D94E_DHU_logging_and_log_files);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_DiagDID_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_DiagDID_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_F190_Vehicle_Identification_Number(const std::array<uint8_t,17>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_F190_Vehicle_Identification_Number);
        signal.value.int32Values.resize(17,0);
        for(size_t i=0;i<17;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_D92D_Phone_Call_active(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_D92D_Phone_Call_active);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD2A_Gyroscope_reading(const std::array<uint8_t,12>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD2A_Gyroscope_reading);
        signal.value.int32Values.resize(12,0);
        for(size_t i=0;i<12;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD22_FM_Tuner_Frequency_reading(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD22_FM_Tuner_Frequency_reading);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD21_AM_Tuner_Frequency_reading(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD21_AM_Tuner_Frequency_reading);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD24_Audio_DAB_reading(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD24_Audio_DAB_reading);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD84_BT_Address_Reading(const std::array<uint8_t,6>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD84_BT_Address_Reading);
        signal.value.int32Values.resize(6,0);
        for(size_t i=0;i<6;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD96_WIFI_Address_Reading(const std::array<uint8_t,6>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD96_WIFI_Address_Reading);
        signal.value.int32Values.resize(6,0);
        for(size_t i=0;i<6;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD29_Control_Audio_input_Source(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD29_Control_Audio_input_Source);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD12_Audio_Signal_generation(const std::array<uint8_t,4>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD12_Audio_Signal_generation);
        signal.value.int32Values.resize(4,0);
        for(size_t i=0;i<4;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD17_Display_output_control(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD17_Display_output_control);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD18_Camera_input_control(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD18_Camera_input_control);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD33_Audio_tuner_setting(const std::array<uint8_t,6>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD33_Audio_tuner_setting);
        signal.value.int32Values.resize(6,0);
        for(size_t i=0;i<6;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD23_Tuner_Automatic_search_setting(const std::array<uint8_t,5>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD23_Tuner_Automatic_search_setting);
        signal.value.int32Values.resize(5,0);
        for(size_t i=0;i<5;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD41_USB_communication_control(const std::array<uint8_t,3>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD41_USB_communication_control);
        signal.value.int32Values.resize(3,0);
        for(size_t i=0;i<3;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD85_BT_function_On_Off_control(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD85_BT_function_On_Off_control);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD86_Bluetooth_device_visibility_switch_setting(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD86_Bluetooth_device_visibility_switch_setting);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD91_WIFI_function_On_Off_control(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD91_WIFI_function_On_Off_control);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD94_Bluetooth_Loopback_Mode_setting(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD94_Bluetooth_Loopback_Mode_setting);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD97_WIFI_mode_setting(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD97_WIFI_mode_setting);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_C012_Security_Audit_Log_OTA_Events(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_C012_Security_Audit_Log_OTA_Events);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_FD88_ADB_Switch(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_FD88_ADB_Switch);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_CSD_MONITOR_EN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CSD_MONITOR_EN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_PASWAM_Video_in() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_PASWAM_Video_in));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_DVR_Video_IN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DVR_Video_IN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_Gesture_Video_IN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Gesture_Video_IN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_Chat_Video_IN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Chat_Video_IN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_Dcm_D912_PSD_MONITOR_EN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Dcm_D912_PSD_MONITOR_EN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_D94E_DHU_logging_and_log_files() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_D94E_DHU_logging_and_log_files));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_Product_Serial_Number() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Product_Serial_Number));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType24 IPCPSignalManager::getPA_XDSN_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_XDSN_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType24>(signal->value.bytes);
        }
        return PAIntArrayFuncType24{};
    }

    PAIntArrayFuncType24 IPCPSignalManager::getPA_IHUID_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_IHUID_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType24>(signal->value.bytes);
        }
        return PAIntArrayFuncType24{};
    }

    PAIntArrayFuncType40 IPCPSignalManager::getPA_HW_Version_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_HW_Version_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType40>(signal->value.bytes);
        }
        return PAIntArrayFuncType40{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_Geely_Delivery_Assemble_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Geely_Delivery_Assemble_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_GeelyHSWD_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_GeelyHSWD_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_VolvoDelivery_Assemble_Reading() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VolvoDelivery_Assemble_Reading));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_Manufacturing_Signal() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Manufacturing_Signal));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_D907() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_D907));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_CSDM_PSD_EN() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_CSDM_PSD_EN));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD29_Control_Audio_input_Source() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD29_Control_Audio_input_Source));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_FD12_Audio_Signal_generation() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD12_Audio_Signal_generation));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD17_Display_output_generation() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD17_Display_output_generation));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD18_Camera_input_generation() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD18_Camera_input_generation));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_FD33_Audio_tuner_setting() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD33_Audio_tuner_setting));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_FD23_Tuner_Automatic_search_setting() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD23_Tuner_Automatic_search_setting));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD41_USB_communication_control() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD41_USB_communication_control));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD85_BT_function_On_Off_control() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD85_BT_function_On_Off_control));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD86_Bluetooth_device_visibility_switch_setting() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD86_Bluetooth_device_visibility_switch_setting));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD91_WIFI_function_On_Off_control() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD91_WIFI_function_On_Off_control));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD94_Bluetooth_Loopback_Mode_setting() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD94_Bluetooth_Loopback_Mode_setting));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD97_WIFI_mode_setting() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD97_WIFI_mode_setting));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FD88_ADB_Switch() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FD88_ADB_Switch));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    PAIntArrayFuncType8 IPCPSignalManager::getPA_F12A_ECU_Core_Assembly_PartNumber() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_F12A_ECU_Core_Assembly_PartNumber));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType8>(signal->value.bytes);
        }
        return PAIntArrayFuncType8{};
    }

    void IPCPSignalManager::setDiagOTAReboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::DiagOTAReboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_OTA_Display_version_D0D0(const std::array<uint8_t,60>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_OTA_Display_version_D0D0);
        signal.value.int32Values.resize(60,0);
        for(size_t i=0;i<60;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_OTA_Baseline_SW_Structure_Identifier_D0D1(const std::array<uint8_t,42>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_OTA_Baseline_SW_Structure_Identifier_D0D1);
        signal.value.int32Values.resize(42,0);
        for(size_t i=0;i<42;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_OTA_description_D0D2(const std::array<uint8_t,1024>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_OTA_description_D0D2);
        signal.value.int32Values.resize(1024,0);
        for(size_t i=0;i<1024;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntArrayFuncType64 IPCPSignalManager::getPA_OTA_Display_version_D0D0() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_OTA_Display_version_D0D0));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType64>(signal->value.bytes);
        }
        return PAIntArrayFuncType64{};
    }

    PAIntArrayFuncType48 IPCPSignalManager::getPA_OTA_Baseline_SW_Structure_Identifier_D0D1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_OTA_Baseline_SW_Structure_Identifier_D0D1));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType48>(signal->value.bytes);
        }
        return PAIntArrayFuncType48{};
    }

    PAIntArrayFuncType1024 IPCPSignalManager::getPA_OTA_description_D0D2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_OTA_description_D0D2));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType1024>(signal->value.bytes);
        }
        return PAIntArrayFuncType1024{};
    }

    void IPCPSignalManager::setCB_Dcm_D02E_VLANPriority(const std::array<uint8_t,4>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_D02E_VLANPriority);
        signal.value.int32Values.resize(4,0);
        for(size_t i=0;i<4;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_DED0_CustomerSettingParameters(const std::array<uint8_t,5>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_DED0_CustomerSettingParameters);
        signal.value.int32Values.resize(5,0);
        for(size_t i=0;i<5;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_DED1_SystemAdaptionData(const std::array<uint8_t,5>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_DED1_SystemAdaptionData);
        signal.value.int32Values.resize(5,0);
        for(size_t i=0;i<5;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F12E_ECUSoftwarePartNumbers_IHUAPLoadModulePartNumber(const std::array<uint8_t,7>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F12E_ECUSoftwarePartNumbers_IHUAPLoadModulePartNumber);
        signal.value.int32Values.resize(7,0);
        for(size_t i=0;i<7;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F12E_ECUSoftwarePartNumbers_IHULanguageDBPartNumber(const std::array<uint8_t,7>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F12E_ECUSoftwarePartNumbers_IHULanguageDBPartNumber);
        signal.value.int32Values.resize(7,0);
        for(size_t i=0;i<7;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F12E_ECUSoftwarePartNumbers_IHUMapDataPartNumber(const std::array<uint8_t,7>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F12E_ECUSoftwarePartNumbers_IHUMapDataPartNumber);
        signal.value.int32Values.resize(7,0);
        for(size_t i=0;i<7;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F12E_ECUSoftwarePartNumbers_IHUAPLocalConfigPartNumber(const std::array<uint8_t,7>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F12E_ECUSoftwarePartNumbers_IHUAPLocalConfigPartNumber);
        signal.value.int32Values.resize(7,0);
        for(size_t i=0;i<7;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUAPLoadModulePartNumber(const std::array<uint8_t,8>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUAPLoadModulePartNumber);
        signal.value.int32Values.resize(8,0);
        for(size_t i=0;i<8;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHULanguageDBPartNumber(const std::array<uint8_t,8>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHULanguageDBPartNumber);
        signal.value.int32Values.resize(8,0);
        for(size_t i=0;i<8;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUMapDataPartNumber(const std::array<uint8_t,8>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUMapDataPartNumber);
        signal.value.int32Values.resize(8,0);
        for(size_t i=0;i<8;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUAPLocalConfigPartNumber(const std::array<uint8_t,8>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_F1AE_ECUSoftwarePartNumbersGeely_IHUAPLocalConfigPartNumber);
        signal.value.int32Values.resize(8,0);
        for(size_t i=0;i<8;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_Inhibit_AP_SWDL(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_Inhibit_AP_SWDL);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_CNCAP(const std::array<uint8_t,4>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_CNCAP);
        signal.value.int32Values.resize(4,0);
        for(size_t i=0;i<4;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_CNCAPVP(const std::array<uint8_t,22>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_CNCAPVP);
        signal.value.int32Values.resize(22,0);
        for(size_t i=0;i<22;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CSD_GW_RESPONSE(const std::array<uint8_t,105>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CSD_GW_RESPONSE);
        signal.value.int32Values.resize(105,0);
        for(size_t i=0;i<105;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_C00E_SAL_KeyManagement(const std::array<uint8_t,144>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_C00E_SAL_KeyManagement);
        signal.value.int32Values.resize(144,0);
        for(size_t i=0;i<144;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_C00F_SAL_SystemAccess(const std::array<uint8_t,185>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_C00F_SAL_SystemAccess);
        signal.value.int32Values.resize(185,0);
        for(size_t i=0;i<185;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Dcm_C012_SAL_OTAEvents(const std::array<uint8_t,309>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Dcm_C012_SAL_OTAEvents);
        signal.value.int32Values.resize(309,0);
        for(size_t i=0;i<309;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_DiagProxy_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_DiagProxy_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AP_DiagGWReady(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AP_DiagGWReady);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_CSDM_GW_RESPONSE(const std::array<uint8_t,80>& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_CSDM_GW_RESPONSE);
        signal.value.int32Values.resize(80,0);
        for(size_t i=0;i<80;i++){
            signal.value.int32Values[i]=value[i];
        }
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntArrayFuncType56 IPCPSignalManager::getPA_DiagProxy_Status() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DiagProxy_Status));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType56>(signal->value.bytes);
        }
        return PAIntArrayFuncType56{};
    }

    PAIntArrayFuncType40 IPCPSignalManager::getPA_DiagProxy_Csd_GW_Phy() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DiagProxy_Csd_GW_Phy));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType40>(signal->value.bytes);
        }
        return PAIntArrayFuncType40{};
    }

    PAIntArrayFuncType40 IPCPSignalManager::getPA_DiagProxy_Csd_GW_Fun() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DiagProxy_Csd_GW_Fun));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType40>(signal->value.bytes);
        }
        return PAIntArrayFuncType40{};
    }

    PAIntArrayFuncType40 IPCPSignalManager::getPA_DiagProxy_Csdm_GW_Phy() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DiagProxy_Csdm_GW_Phy));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType40>(signal->value.bytes);
        }
        return PAIntArrayFuncType40{};
    }

    PAIntArrayFuncType40 IPCPSignalManager::getPA_DiagProxy_Csdm_GW_Fun() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_DiagProxy_Csdm_GW_Fun));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType40>(signal->value.bytes);
        }
        return PAIntArrayFuncType40{};
    }

    PAIntArrayFuncType4 IPCPSignalManager::getPA_FEFD_Send_VFC_Id() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_FEFD_Send_VFC_Id));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntArrayFuncType4>(signal->value.bytes);
        }
        return PAIntArrayFuncType4{};
    }

    void IPCPSignalManager::setCB_AP_D08100_Incompatible_IP_bus_Signal_Received_From_TCAM(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AP_D08100_Incompatible_IP_bus_Signal_Received_From_TCAM);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AP_D0B000_VGM_Not_Connected_On_Ethernet(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AP_D0B000_VGM_Not_Connected_On_Ethernet);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_AP_454600_VIN_Not_Programmed_or_Incompatible(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_AP_454600_VIN_Not_Programmed_or_Incompatible);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAStringFuncType32 IPCPSignalManager::getPA_EC_Version() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_EC_Version));
        }
        if (signal.has_value()){
            return utils::toValue<PAStringFuncType32>(signal->value.bytes);
        }
        return PAStringFuncType32{};
    }

    PAIntFuncType IPCPSignalManager::getPA_AmpDiagResult() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_AmpDiagResult));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAStringFuncType1400 IPCPSignalManager::getPA_McuLog_Panic() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_McuLog_Panic));
        }
        if (signal.has_value()){
            return utils::toValue<PAStringFuncType1400>(signal->value.bytes);
        }
        return PAStringFuncType1400{};
    }

    void IPCPSignalManager::setCB_Power_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_ResetSettings(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_ResetSettings);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_APStatus(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_APStatus);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_Restart(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_Restart);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_BG(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_BG);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_IPLMInfo(uint32_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_IPLMInfo);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_OTAUpdate(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_OTAUpdate);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_Softkey(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_Softkey);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_CSDBL(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_CSDBL);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_PSDBL(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_PSDBL);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Power_CSDOnOff(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Power_CSDOnOff);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PwrctrlVptoapimpl IPCPSignalManager::getPA_Power_Res() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_Power_Res));
        }
        if (signal.has_value()){
            return utils::toValue<PwrctrlVptoapimpl>(signal->value.bytes);
        }
        return PwrctrlVptoapimpl{};
    }

    void IPCPSignalManager::setCB_RstMntnMilg(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_RstMntnMilg);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntFuncType IPCPSignalManager::getPA_srvTrig() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_srvTrig));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_AdasTripMileage() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_AdasTripMileage));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_AdasTripDate() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_AdasTripDate));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    void IPCPSignalManager::setCB_Chime_ModeSts(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Chime_ModeSts);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_Chime_WarnIDSts(const Chime_WarnIDStsData& value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_Chime_WarnIDSts);
        auto bytes = utils::toBytes(value);
        signal.value.bytes=(std::vector<uint8_t>)bytes;
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_IPWakeup(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_IPWakeup);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_FaceIdnForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_FaceIdnForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_TelephoneManager(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_TelephoneManager);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehCenClkIndcnAndSetg(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehCenClkIndcnAndSetg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehPrivateLock(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehPrivateLock);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehApa(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehApa);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehAvm(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehAvm);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehTcam(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehTcam);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehDvr(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehDvr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFCRsrv1(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFCRsrv1);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFCRsrv2(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFCRsrv2);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFCRsrv3(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFCRsrv3);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFCRsrv4(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFCRsrv4);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFCRsrv5(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFCRsrv5);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_SetVehFace(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_SetVehFace);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_FitnessMonitoring(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_FitnessMonitoring);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ExteriorLightShow(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ExteriorLightShow);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_VehSurrndgsVisn(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_VehSurrndgsVisn);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_NavigationInfoSharing(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_NavigationInfoSharing);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SceneMode(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SceneMode);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_StrangerModeForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_StrangerModeForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ScenePetModeForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ScenePetModeForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_StrangerModeForHmiCenIP(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_StrangerModeForHmiCenIP);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SecRowFaceIdnForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SecRowFaceIdnForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SceneBiochalModeForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SceneBiochalModeForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SpeechCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SpeechCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SecFaceIdnSumMgr(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SecFaceIdnSumMgr);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SceneCarWashModeForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SceneCarWashModeForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_PinToDrvForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_PinToDrvForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ExteriorLightShowWin(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ExteriorLightShowWin);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_GenChaSettingsForHmiCenIP(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_GenChaSettingsForHmiCenIP);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ActvReSplrMgrIP(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ActvReSplrMgrIP);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SuspCtrlForHmiCenIP(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SuspCtrlForHmiCenIP);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SeatComfortFunctions(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SeatComfortFunctions);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MirrCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MirrCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MirrCtrlForHmiCen_3s(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MirrCtrlForHmiCen_3s);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MirrCtrlForHmiCen_10s(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MirrCtrlForHmiCen_10s);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_DimWinMgrWin(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_DimWinMgrWin);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_Weather(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_Weather);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_InterLightShow(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_InterLightShow);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehSeatCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehSeatCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehSystem(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehSystem);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehIntrLiCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehIntrLiCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehCrtlAdas(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehCrtlAdas);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehDrvMode(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehDrvMode);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehMisc(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehMisc);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehCharging(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehCharging);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehMobileEquipWirelsChrg(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehMobileEquipWirelsChrg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehSmallCycle(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehSmallCycle);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehMmedbtnifLS(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehMmedbtnifLS);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_V2XCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_V2XCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_PwrDoorCtrlForHmiCenPC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_PwrDoorCtrlForHmiCenPC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ActvReSplrForHmiCenPC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ActvReSplrForHmiCenPC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ActvReSplrMgrPC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ActvReSplrMgrPC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_TrlrAndTwbrCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_TrlrAndTwbrCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SeatClimaForHmiCenPDC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SeatClimaForHmiCenPDC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SteerWhlHeatgCtrlForHmiCenPDC(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SteerWhlHeatgCtrlForHmiCenPDC);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MmedbtnifClimate(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MmedbtnifClimate);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MmedbtnifSeatAdjustment(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MmedbtnifSeatAdjustment);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_MirrCtrlForDrvrHmiVisibility(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_MirrCtrlForDrvrHmiVisibility);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ProfCtrlForHmiCenSP_30s(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ProfCtrlForHmiCenSP_30s);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ProfCtrlForHmiCenSP_3s(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ProfCtrlForHmiCenSP_3s);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetProPrsnlSetg(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetProPrsnlSetg);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehProfile(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehProfile);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_DigKeyCtrlForHmiCenIP(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_DigKeyCtrlForHmiCenIP);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_IonizerAirClngCtrlForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_IonizerAirClngCtrlForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_SetVehHud(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_SetVehHud);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_ACChrgnForHmiCen(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_ACChrgnForHmiCen);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_GlobalShortOTA(sdb::OnOff1 value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_GlobalShortOTA);
        signal.value.int32Values={(int32_t)value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    void IPCPSignalManager::setCB_VFC_Reboot(uint8_t value) const{
        Signal signal;
        signal.signalId=static_cast<uint32_t>(CBSignal::CB_VFC_Reboot);
        signal.value.int32Values={value};
        if(mIPCPConn != nullptr){
            mIPCPConn->write(signal);
        }
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_IPWakeup() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_IPWakeup));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_FaceIdnForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_FaceIdnForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_TelephoneManager() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_TelephoneManager));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehCenClkIndcnAndSetg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehCenClkIndcnAndSetg));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehPrivateLock() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehPrivateLock));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehApa() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehApa));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehAvm() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehAvm));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehTcam() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehTcam));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehDvr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehDvr));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFCRsrv1() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFCRsrv1));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFCRsrv2() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFCRsrv2));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFCRsrv3() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFCRsrv3));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFCRsrv4() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFCRsrv4));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFCRsrv5() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFCRsrv5));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehFace() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehFace));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VFC_Reboot() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VFC_Reboot));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_FitnessMonitoring() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_FitnessMonitoring));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ExteriorLightShow() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ExteriorLightShow));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_VehSurrndgsVisn() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_VehSurrndgsVisn));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_NavigationInfoSharing() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_NavigationInfoSharing));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SceneMode() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SceneMode));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_StrangerModeForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_StrangerModeForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ScenePetModeForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ScenePetModeForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_StrangerModeForHmiCenIP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_StrangerModeForHmiCenIP));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SecRowFaceIdnForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SecRowFaceIdnForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SceneBiochalModeForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SceneBiochalModeForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SpeechCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SpeechCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SecFaceIdnSumMgr() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SecFaceIdnSumMgr));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SceneCarWashModeForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SceneCarWashModeForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_PinToDrvForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_PinToDrvForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ExteriorLightShowWin() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ExteriorLightShowWin));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_GenChaSettingsForHmiCenIP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_GenChaSettingsForHmiCenIP));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ActvReSplrMgrIP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ActvReSplrMgrIP));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SuspCtrlForHmiCenIP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SuspCtrlForHmiCenIP));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SeatComfortFunctions() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SeatComfortFunctions));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MirrCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MirrCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MirrCtrlForHmiCen_3s() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MirrCtrlForHmiCen_3s));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MirrCtrlForHmiCen_10s() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MirrCtrlForHmiCen_10s));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_DimWinMgrWin() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_DimWinMgrWin));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_Weather() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_Weather));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_InterLightShow() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_InterLightShow));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehSeatCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehSeatCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehSystem() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehSystem));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehIntrLiCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehIntrLiCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehCrtlAdas() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehCrtlAdas));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehDrvMode() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehDrvMode));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehMisc() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehMisc));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehCharging() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehCharging));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehMobileEquipWirelsChrg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehMobileEquipWirelsChrg));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehSmallCycle() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehSmallCycle));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehMmedbtnifLS() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehMmedbtnifLS));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_V2XCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_V2XCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_PwrDoorCtrlForHmiCenPC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_PwrDoorCtrlForHmiCenPC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ActvReSplrForHmiCenPC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ActvReSplrForHmiCenPC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ActvReSplrMgrPC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ActvReSplrMgrPC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_TrlrAndTwbrCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_TrlrAndTwbrCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SeatClimaForHmiCenPDC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SeatClimaForHmiCenPDC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SteerWhlHeatgCtrlForHmiCenPDC() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SteerWhlHeatgCtrlForHmiCenPDC));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MmedbtnifClimate() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MmedbtnifClimate));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MmedbtnifSeatAdjustment() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MmedbtnifSeatAdjustment));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_MirrCtrlForDrvrHmiVisibility() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_MirrCtrlForDrvrHmiVisibility));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ProfCtrlForHmiCenSP_30s() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ProfCtrlForHmiCenSP_30s));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ProfCtrlForHmiCenSP_3s() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ProfCtrlForHmiCenSP_3s));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetProPrsnlSetg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetProPrsnlSetg));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehProfile() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehProfile));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_DigKeyCtrlForHmiCenIP() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_DigKeyCtrlForHmiCenIP));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_IonizerAirClngCtrlForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_IonizerAirClngCtrlForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_SetVehHud() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_SetVehHud));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_ACChrgnForHmiCen() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_ACChrgnForHmiCen));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VFC_GlobalShortOTA() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VFC_GlobalShortOTA));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAStringFuncType20 IPCPSignalManager::getPA_VIN_VinNum() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VIN_VinNum));
        }
        if (signal.has_value()){
            return utils::toValue<PAStringFuncType20>(signal->value.bytes);
        }
        return PAStringFuncType20{};
    }

    PAIntFuncType IPCPSignalManager::getPA_VINDiffMsg() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VINDiffMsg));
        }
        if (signal.has_value()){
            return utils::toValue<PAIntFuncType>(signal->value.bytes);
        }
        return PAIntFuncType{};
    }

    PAStringFuncType32 IPCPSignalManager::getPA_VP_Version() const {
        std::optional<Signal> signal;
        if(mIPCPConn != nullptr){
            signal=mIPCPConn->read(static_cast<int32_t>(PASignal::PA_VP_Version));
        }
        if (signal.has_value()){
            return utils::toValue<PAStringFuncType32>(signal->value.bytes);
        }
        return PAStringFuncType32{};
    }
 
}
